From cde1868f9caee9b6335fa5988463d173fecde3ae Mon Sep 17 00:00:00 2001
From: Peter Ohm <pohm@sandia.gov>
Date: Fri, 15 Nov 2019 13:28:47 -0700
Subject: [PATCH 01/21] MueLu: adding region vector unit-test. Added tests for
 regionalToComposite and compositeToRegional.

---
 packages/muelu/test/unit_tests/CMakeLists.txt |   2 +-
 .../muelu/test/unit_tests/RegionVector.cpp    | 381 ++++++++++++++++++
 2 files changed, 382 insertions(+), 1 deletion(-)
 create mode 100644 packages/muelu/test/unit_tests/RegionVector.cpp

diff --git a/packages/muelu/test/unit_tests/CMakeLists.txt b/packages/muelu/test/unit_tests/CMakeLists.txt
index 652b851c25e8..26382f402a0f 100644
--- a/packages/muelu/test/unit_tests/CMakeLists.txt
+++ b/packages/muelu/test/unit_tests/CMakeLists.txt
@@ -195,7 +195,7 @@ IF (${PACKAGE_NAME}_ENABLE_Zoltan AND TPL_ENABLE_MPI)
 ENDIF()
 
 IF (${PACKAGE_NAME}_ENABLE_Experimental AND ${PACKAGE_NAME}_ENABLE_Tpetra AND ${PACKAGE_NAME}_ENABLE_Ifpack2 AND ${PACKAGE_NAME}_ENABLE_Amesos2)
-  APPEND_SET(SOURCES_REGION RegionMatrix.cpp)
+  APPEND_SET(SOURCES_REGION RegionMatrix.cpp RegionVector.cpp)
 ENDIF()
 
 IF (${PACKAGE_NAME}_ENABLE_Galeri) #TMP
diff --git a/packages/muelu/test/unit_tests/RegionVector.cpp b/packages/muelu/test/unit_tests/RegionVector.cpp
new file mode 100644
index 000000000000..e7425d6d24d3
--- /dev/null
+++ b/packages/muelu/test/unit_tests/RegionVector.cpp
@@ -0,0 +1,381 @@
+// @HEADER
+//
+// ***********************************************************************
+//
+//        MueLu: A package for multigrid based preconditioning
+//                  Copyright 2012 Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact
+//                    Jonathan Hu       (jhu@sandia.gov)
+//                    Andrey Prokopenko (aprokop@sandia.gov)
+//                    Ray Tuminaro      (rstumin@sandia.gov)
+//
+// ***********************************************************************
+//
+// @HEADER
+#include "Teuchos_UnitTestHarness.hpp"
+#include "MueLu_TestHelpers.hpp"
+#include "MueLu_Version.hpp"
+
+#include <Galeri_XpetraParameters.hpp>
+
+// Region MG headers
+#include "SetupRegionUtilities.hpp"
+#include "SetupRegionVector_def.hpp"
+#include "SetupRegionMatrix_def.hpp"
+
+namespace MueLuTests {
+
+TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionVector, RegionCompositeVector, Scalar, LocalOrdinal, GlobalOrdinal, Node)
+{
+#   include "MueLu_UseShortNames.hpp"
+  MUELU_TESTING_SET_OSTREAM;
+  MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node);
+
+  using TST                   = Teuchos::ScalarTraits<SC>;
+  using magnitude_type        = typename TST::magnitudeType;
+  using TMT                   = Teuchos::ScalarTraits<magnitude_type>;
+  using real_type             = typename TST::coordinateType;
+  using RealValuedMultiVector = Xpetra::MultiVector<real_type,LO,GO,NO>;
+  using test_factory          = TestHelpers::TestFactory<SC, LO, GO, NO>;
+
+  out << "version: " << MueLu::Version() << std::endl;
+
+  // Get MPI parameter
+  RCP<const Teuchos::Comm<int> > comm = TestHelpers::Parameters::getDefaultComm();
+  LO numRanks = comm->getSize();
+  LO myRank = comm->getRank();
+
+  GO nx = 5, ny = 5, nz = 1;
+  Teuchos::CommandLineProcessor &clp = Teuchos::UnitTestRepository::getCLP();
+  Galeri::Xpetra::Parameters<GO> galeriParameters(clp, nx, ny, nz, "Laplace2D");
+  Teuchos::ParameterList galeriList = galeriParameters.GetParameterList();
+  std::string   matrixType = galeriParameters.GetMatrixType();
+
+  // Build maps for the problem
+  const LO numDofsPerNode = 1;
+  RCP<Map> nodeMap = Galeri::Xpetra::CreateMap<LO, GO, Node>(TestHelpers::Parameters::getLib(),
+                                                             "Cartesian2D", comm, galeriList);
+  RCP<Map> dofMap  = Xpetra::MapFactory<LO,GO,Node>::Build(nodeMap, numDofsPerNode);
+
+  // Build the Xpetra problem
+  RCP<Galeri::Xpetra::Problem<Map,CrsMatrixWrap,MultiVector> > Pr =
+    Galeri::Xpetra::BuildProblem<SC,LO,GO,Map,CrsMatrixWrap,MultiVector>(galeriParameters.GetMatrixType(), dofMap, galeriList);
+
+  // Generate the operator
+  RCP<Matrix> A = Pr->BuildMatrix();
+  A->SetFixedBlockSize(numDofsPerNode);
+
+  // Set global geometric data
+  Array<LO> lNodesPerDir(3);
+  Array<GO> gNodesPerDir(3);
+  Array<GO> procsPerDim(3);
+  gNodesPerDir[0] = galeriList.get<GO>("nx");
+  gNodesPerDir[1] = galeriList.get<GO>("ny");
+  gNodesPerDir[2] = 1;
+  lNodesPerDir[0] = galeriList.get<LO>("lnx");
+  lNodesPerDir[1] = galeriList.get<LO>("lny");
+  lNodesPerDir[2] = 1;
+  procsPerDim[0] = galeriList.get<GO>("mx");
+  procsPerDim[1] = galeriList.get<GO>("my");
+  procsPerDim[2] = 1;
+
+  Array<int> boundaryConditions;
+  int maxRegPerGID = 0;
+  int numInterfaces = 0;
+  LO numLocalRegionNodes = 0;
+  Array<GO>  sendGIDs;
+  Array<int> sendPIDs;
+  Array<LO>  rNodesPerDim(3);
+  Array<LO>  compositeToRegionLIDs(nodeMap->getNodeNumElements()*numDofsPerNode);
+  Array<GO>  quasiRegionGIDs;
+  Array<GO>  quasiRegionCoordGIDs;
+  createRegionData(2, false, numDofsPerNode,
+                   gNodesPerDir(), lNodesPerDir(), procsPerDim(),
+                   nodeMap, dofMap,
+                   maxRegPerGID, numLocalRegionNodes, boundaryConditions,
+                   sendGIDs, sendPIDs, numInterfaces, rNodesPerDim,
+                   quasiRegionGIDs, quasiRegionCoordGIDs, compositeToRegionLIDs);
+
+  const int maxRegPerProc = 1;
+  std::vector<RCP<Map> > rowMapPerGrp(maxRegPerProc),        colMapPerGrp(maxRegPerProc);
+  rowMapPerGrp[0] = Xpetra::MapFactory<LO,GO,Node>::Build(A->getRowMap()->lib(),
+                                                          Teuchos::OrdinalTraits<GO>::invalid(),
+                                                          quasiRegionGIDs(),
+                                                          A->getRowMap()->getIndexBase(),
+                                                          A->getRowMap()->getComm());
+  colMapPerGrp[0] = rowMapPerGrp[0];
+
+  std::vector<RCP<Map> > revisedRowMapPerGrp(maxRegPerProc), revisedColMapPerGrp(maxRegPerProc);
+  revisedRowMapPerGrp[0] = Xpetra::MapFactory<LO,GO,Node>::Build(A->getRowMap()->lib(),
+                                                                 Teuchos::OrdinalTraits<GO>::invalid(),
+                                                                 quasiRegionGIDs.size()*numDofsPerNode,
+                                                                 A->getRowMap()->getIndexBase(),
+                                                                 A->getRowMap()->getComm());
+  revisedColMapPerGrp[0] = revisedRowMapPerGrp[0];
+
+  std::vector<RCP<Import> > rowImportPerGrp(maxRegPerProc);
+  std::vector<RCP<Import> > colImportPerGrp(maxRegPerProc);
+  rowImportPerGrp[0] = ImportFactory::Build(dofMap, rowMapPerGrp[0]);
+  colImportPerGrp[0] = ImportFactory::Build(dofMap, colMapPerGrp[0]);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  { // test compositeToRegional
+    // Create a composite vector
+    RCP<Vector> compVec = VectorFactory::Build(dofMap);
+    TEUCHOS_ASSERT(!compVec.is_null());
+    compVec->putScalar(0.0);
+    const size_t localLength = compVec->getLocalLength();
+    for (size_t k = 0; k < localLength; ++k) {
+      compVec->replaceLocalValue(k, k + myRank/10.0);// (LO, Scalar) need to fix type of k
+    }
+
+    // Create a region vector
+    Array<RCP<Vector> > regVec(maxRegPerProc);
+    Array<Teuchos::RCP<Vector> > quasiRegVec(maxRegPerProc);
+
+    compositeToRegional(compVec, quasiRegVec, regVec, maxRegPerProc, rowMapPerGrp, revisedRowMapPerGrp, rowImportPerGrp);
+
+    //RCP<Teuchos::FancyOStream> outF = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
+    //std::cout<<"compVec:"<<std::endl;
+    //compVec->describe(*outF, Teuchos::VERB_EXTREME);
+    //std::cout<<"Quasi:"<<std::endl;
+    //quasiRegVec[0]->describe(*outF, Teuchos::VERB_EXTREME);
+    //std::cout<<"Reg:"<<std::endl;
+    //regVec[0]->describe(*outF, Teuchos::VERB_EXTREME);
+    if(numRanks == 1){
+      TEST_EQUALITY(regVec[0]->getLocalLength(),  25);
+      TEST_EQUALITY(regVec[0]->getGlobalLength(), 25);
+      TEST_EQUALITY(quasiRegVec[0]->getLocalLength(),  25);
+      TEST_EQUALITY(quasiRegVec[0]->getGlobalLength(), 25);
+      ArrayRCP<SC> refValues;
+      Teuchos::ArrayRCP<const SC> myValues;
+      refValues.deepCopy(ArrayView<const SC>({0.0, 1, 2, 3, 4,
+                                               5, 6, 7, 8, 9,
+                                              10, 11, 12, 13, 14,
+                                              15, 16, 17, 18, 19,
+                                              20, 21, 22, 23, 24}));
+      for (int j = 0; j < maxRegPerProc; j++) {
+        myValues = regVec[j]->getData(0);
+        for(int idx = 0; idx < regVec[j]->getLocalLength(); ++idx) {
+          TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
+        }
+        myValues = quasiRegVec[j]->getData(0);
+        for(int idx = 0; idx < quasiRegVec[j]->getLocalLength(); ++idx) {
+          TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
+        }
+
+      }
+
+    } else if(numRanks == 4) {
+      // All ranks will have the same number of rows/cols/entries
+      TEST_EQUALITY(regVec[0]->getLocalLength(),  9);
+      TEST_EQUALITY(regVec[0]->getGlobalLength(), 36);
+      TEST_EQUALITY(quasiRegVec[0]->getLocalLength(),  9);
+      TEST_EQUALITY(quasiRegVec[0]->getGlobalLength(), 36);
+
+      ArrayRCP<SC> refValues;
+      Teuchos::ArrayRCP<const SC> myValues;
+      if(myRank == 0) {
+        refValues.deepCopy(ArrayView<const SC>({0.0, 1, 2, 3, 4, 5, 6, 7, 8}));
+
+      } else if(myRank == 1) {
+        refValues.deepCopy(ArrayView<const SC>({2.0, 0.1, 1.1, 5.0, 2.1, 3.1, 8.0, 4.1, 5.1}));
+
+      } else if(myRank == 2) {
+        refValues.deepCopy(ArrayView<const SC>({6, 7, 8, 0.2, 1.2, 2.2, 3.2, 4.2, 5.2}));
+
+      } else if(myRank == 3) {
+        refValues.deepCopy(ArrayView<const SC>({8, 4.1, 5.1, 2.2, 0.3, 1.3, 5.2, 2.3, 3.3}));
+      }
+      // Loop over region matrix data and compare it to ref data
+      for (int j = 0; j < maxRegPerProc; j++){
+        myValues = regVec[j]->getData(0);
+        for(int idx = 0; idx < regVec[j]->getLocalLength(); ++idx) {
+          TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
+        }
+        myValues = quasiRegVec[j]->getData(0);
+        for(int idx = 0; idx < quasiRegVec[j]->getLocalLength(); ++idx) {
+          TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
+        }
+      }
+    }
+
+  }
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  {
+    // Create a region vector
+    Array<RCP<Vector> > regVec(maxRegPerProc);
+    for (int j = 0; j < maxRegPerProc; j++) {
+      regVec[j] = VectorFactory::Build(revisedRowMapPerGrp[j]);
+      regVec[j]->putScalar( myRank / 10.0 );
+      for (size_t k = 0; k < regVec[j]->getLocalLength(); ++k){
+        regVec[j]->sumIntoLocalValue(k, k);
+      }
+    }
+
+    // Create a composite vector
+    RCP<Vector> compVec = VectorFactory::Build(dofMap, true);
+
+    regionalToComposite(regVec, compVec, maxRegPerProc, rowMapPerGrp, rowImportPerGrp, Xpetra::ADD);
+
+    if(numRanks == 1) {
+      TEST_EQUALITY(compVec->getLocalLength(),  25);
+      TEST_EQUALITY(compVec->getGlobalLength(), 25);
+
+      ArrayRCP<SC> refValues;
+      Teuchos::ArrayRCP<const SC> myValues;
+      refValues.deepCopy(ArrayView<const SC>({0.0, 1.0, 2.0, 3.0, 4.0,
+                                              5.0, 6.0, 7.0, 8.0, 9.0,
+                                              10.0, 11.0, 12.0, 13.0, 14.0,
+                                              15.0, 16.0, 17.0, 18.0, 19.0,
+                                              20.0, 21.0, 22.0, 23.0, 24.0}));
+      myValues = compVec->getData(0);
+      for(int idx = 0; idx < compVec->getLocalLength(); ++idx) {
+        TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
+      }
+
+    } else if(numRanks == 4) {
+      // All ranks will have the same number of rows/cols/entries
+      if( myRank == 0){
+        TEST_EQUALITY(compVec->getLocalLength(),  9);
+        TEST_EQUALITY(compVec->getGlobalLength(), 25);
+      } else if (myRank == 1) {
+        TEST_EQUALITY(compVec->getLocalLength(),  6);
+        TEST_EQUALITY(compVec->getGlobalLength(), 25);
+      } else if (myRank == 2) {
+        TEST_EQUALITY(compVec->getLocalLength(),  6);
+        TEST_EQUALITY(compVec->getGlobalLength(), 25);
+      } else if (myRank == 3) {
+        TEST_EQUALITY(compVec->getLocalLength(),  4);
+        TEST_EQUALITY(compVec->getGlobalLength(), 25);
+      }
+
+      ArrayRCP<SC> refValues;
+      Teuchos::ArrayRCP<const SC> myValues;
+      if(myRank == 0) {
+        refValues.deepCopy(ArrayView<const SC>({0.0, 1.0, 2.1, 3.0, 4.0, 8.1, 6.2, 8.2, 16.6}));
+
+      } else if(myRank == 1) {
+        refValues.deepCopy(ArrayView<const SC>({1.1, 2.1, 4.1, 5.1, 8.4, 10.4}));
+
+      } else if(myRank == 2) {
+        refValues.deepCopy(ArrayView<const SC>({3.2, 4.2, 8.5, 6.2, 7.2, 14.5}));
+
+      } else if(myRank == 3) {
+        refValues.deepCopy(ArrayView<const SC>({4.3, 5.3, 7.3, 8.3}));
+      }
+      // Loop over region matrix data and compare it to ref data
+      myValues = compVec->getData(0);
+      for(int idx = 0; idx < compVec->getLocalLength(); ++idx) {
+        TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
+      }
+    }
+  }
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  {
+    // initialize region vector with all ones.
+    Array<RCP<Vector> > interfaceScaling(maxRegPerProc);
+    for (int j = 0; j < maxRegPerProc; j++) {
+      interfaceScaling[j] = VectorFactory::Build(revisedRowMapPerGrp[j]);
+      interfaceScaling[j]->putScalar(1.0);
+    }
+
+    // transform to composite layout while adding interface values via the Export() combine mode
+    RCP<Vector> compInterfaceScalingSum = VectorFactory::Build(dofMap, true);
+    regionalToComposite(interfaceScaling, compInterfaceScalingSum,
+                        maxRegPerProc, rowMapPerGrp, rowImportPerGrp, Xpetra::ADD);
+
+    /* transform composite layout back to regional layout. Now, GIDs associated
+     * with region interface should carry a scaling factor (!= 1).
+     */
+    Array<RCP<Vector> > regVec(maxRegPerProc);
+    Array<RCP<Vector> > quasiRegInterfaceScaling(maxRegPerProc);
+    compositeToRegional(compInterfaceScalingSum, quasiRegInterfaceScaling,
+                        interfaceScaling, maxRegPerProc, rowMapPerGrp,
+                        revisedRowMapPerGrp, rowImportPerGrp);
+
+    if(numRanks == 1) {
+      TEST_EQUALITY(interfaceScaling[0]->getLocalLength(),    25);
+      TEST_EQUALITY(interfaceScaling[0]->getGlobalLength(),   25);
+
+      // No scaling on one rank, so all values are 1.0
+      Teuchos::ArrayRCP<const SC> myScaling;
+      for (int j = 0; j < maxRegPerProc; j++){
+        myScaling = interfaceScaling[j]->getData(0);
+        for(int idx = 0; idx < interfaceScaling[j]->getLocalLength(); ++idx) {
+          TEST_FLOATING_EQUALITY(myScaling[idx], 1.0, 100*TMT::eps());
+        }
+      }
+
+    } else if(numRanks == 4) {
+      // All ranks will have the same number of rows/cols/entries
+      TEST_EQUALITY(interfaceScaling[0]->getLocalLength(),    9);
+      TEST_EQUALITY(interfaceScaling[0]->getGlobalLength(),    36);
+
+      ArrayRCP<SC> refValues;
+      Teuchos::ArrayRCP<const SC> myScaling;
+      if(myRank == 0) {
+        refValues.deepCopy(ArrayView<const SC>({1, 1, 2, 1, 1, 2, 2, 2, 4}));
+
+      } else if(myRank == 1) {
+        refValues.deepCopy(ArrayView<const SC>({2, 1, 1, 2, 1, 1, 4, 2, 2}));
+
+      } else if(myRank == 2) {
+        refValues.deepCopy(ArrayView<const SC>({2, 2, 4, 1, 1, 2, 1, 1, 2}));
+
+      } else if(myRank == 3) {
+        refValues.deepCopy(ArrayView<const SC>({4, 2, 2, 2, 1, 1, 2, 1, 1}));
+      }
+      // Loop over region matrix data and compare it to ref data
+      for (int j = 0; j < maxRegPerProc; j++){
+        myScaling = interfaceScaling[j]->getData(0);
+        for(int idx = 0; idx < interfaceScaling[j]->getLocalLength(); ++idx) {
+          TEST_FLOATING_EQUALITY(myScaling[idx], refValues[idx], 100*TMT::eps());
+        }
+      }
+    }
+
+  }
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+} // RegionCompositeVector
+
+#  define MUELU_ETI_GROUP(Scalar, LO, GO, Node) \
+      TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(RegionVector,RegionCompositeVector,Scalar,LO,GO,Node)
+
+#include <MueLu_ETI_4arg.hpp>
+
+
+} // namespace MueLuTests

From 25570613cf8cb260920bd67ee3f065d16351297f Mon Sep 17 00:00:00 2001
From: Greg Sjaardema <gdsjaar@sandia.gov>
Date: Tue, 19 Nov 2019 08:44:14 -0700
Subject: [PATCH 02/21] Automatic snapshot commit from seacas at a34490f

Origin repo remote tracking branch: 'origin/master'
Origin repo remote repo URL: 'origin = https://github.com/gsjaardema/seacas'

At commit:

commit a34490f6a901f724f7544a486a1fc9d9464b9207
Author:  Greg Sjaardema <gdsjaar@sandia.gov>
Date:    Tue Nov 19 08:08:36 2019 -0700
Summary: SLICE: Fix incorrect equal cal

* Replace case_strcmp with more C++-like str_equal and substr_equal
* Use C++11 class member initialization syntax
* EPU: Check subcycles < proc count
* APREPRO: improve array interactions with other types
* EXODUS: Static analyzer fixes
* CATCH2: Update 2.9.2 -> 2.10.2
* FMT: Update to current version
* PYTHON: minor cleanups in exodus.py and exomerge.py
---
 .../applications/ejoin/EJ_SystemInterface.C   |    26 +-
 packages/seacas/applications/ejoin/EJoin.C    |     6 +-
 .../seacas/applications/epu/EP_ExodusEntity.h |    89 +-
 .../applications/epu/EP_SystemInterface.C     |    33 +-
 .../applications/exodiff/ED_SystemInterface.C |    30 +-
 .../applications/nem_spread/el_exoII_io.C     |     3 +
 .../applications/slice/SL_SystemInterface.C   |    18 +-
 packages/seacas/format.sh                     |     2 +-
 .../libraries/aprepro_lib/apr_aprepro.cc      |     4 +-
 .../libraries/aprepro_lib/apr_builtin.cc      |     3 +-
 .../libraries/aprepro_lib/apr_exodus.cc       |     2 +-
 .../libraries/aprepro_lib/apr_parser.cc       |  1179 +-
 .../libraries/aprepro_lib/apr_scanner.cc      |    12 +-
 .../seacas/libraries/aprepro_lib/aprepro.ll   |     4 +-
 .../seacas/libraries/aprepro_lib/aprepro.yy   |   104 +-
 .../libraries/aprepro_lib/aprepro_parser.h    |    20 +-
 .../seacas/libraries/aprepro_lib/stack.hh     |   157 +
 .../seacas/libraries/exodus/src/ex_create.c   |     6 +-
 .../libraries/exodus/src/ex_create_par.c      |     8 +-
 .../seacas/libraries/exodus/src/ex_get_time.c |    13 +-
 .../seacas/libraries/exodus/src/ex_open.c     |    19 +-
 .../seacas/libraries/exodus/src/ex_open_par.c |    24 +-
 .../seacas/libraries/exodus/src/ex_put_time.c |     2 -
 .../seacas/libraries/exodus/src/ex_utils.c    |     2 +-
 .../seacas/libraries/exodus/test/testrd.c     |     2 +-
 .../libraries/exodus/test/testwt-oned.c       |     1 +
 .../seacas/libraries/ioss/src/CMakeLists.txt  |     6 +-
 .../libraries/ioss/src/Ioss_FaceGenerator.C   |    56 +-
 .../libraries/ioss/src/Ioss_FaceGenerator.h   |    59 +-
 .../libraries/ioss/src/Ioss_GroupingEntity.h  |     2 +-
 .../libraries/ioss/src/Ioss_IOFactory.C       |    13 +-
 .../seacas/libraries/ioss/src/Ioss_Utils.C    |    32 +-
 .../seacas/libraries/ioss/src/Ioss_Utils.h    |    12 +-
 .../libraries/ioss/src/Ioss_VariableType.C    |     2 +-
 .../seacas/libraries/ioss/src/Ioss_Version.h  |    38 +
 packages/seacas/libraries/ioss/src/catch.hpp  | 26153 ++++++++--------
 .../ioss/src/cgns/Iocgns_DecompositionData.C  |     7 +-
 .../libraries/ioss/src/cgns/Iocgns_Utils.C    |     2 +-
 .../ioss/src/exo_fpp/Iofx_DatabaseIO.C        |     2 +-
 .../ioss/src/exo_par/Iopx_DatabaseIO.C        |     2 +-
 .../ioss/src/exodus/Ioex_DatabaseIO.C         |     2 +-
 .../ioss/src/exodus/Ioex_Internals.h          |    86 +-
 .../ioss/src/exodus/Ioex_SuperElement.C       |    10 +-
 .../libraries/ioss/src/exodus/Ioex_Utils.C    |     3 +-
 .../seacas/libraries/ioss/src/fmt/chrono.h    |  1129 +-
 .../seacas/libraries/ioss/src/fmt/color.h     |   795 +-
 .../seacas/libraries/ioss/src/fmt/compile.h   |   730 +-
 packages/seacas/libraries/ioss/src/fmt/core.h |   112 +-
 .../libraries/ioss/src/fmt/format-inl.h       |  1969 +-
 .../seacas/libraries/ioss/src/fmt/format.h    |  5090 +--
 .../seacas/libraries/ioss/src/fmt/ostream.h   |   198 +-
 .../seacas/libraries/ioss/src/fmt/printf.h    |   657 +-
 .../seacas/libraries/ioss/src/fmt/ranges.h    |   403 +-
 .../ioss/src/fmt/safe-duration-cast.h         |   445 +-
 .../libraries/ioss/src/hash/bhopscotch_map.h  |    24 +-
 .../libraries/ioss/src/hash/bhopscotch_set.h  |    22 +-
 .../libraries/ioss/src/hash/hopscotch_hash.h  |     2 +-
 .../libraries/ioss/src/hash/hopscotch_map.h   |     4 +-
 .../libraries/ioss/src/hash/hopscotch_set.h   |     4 +-
 .../libraries/ioss/src/hash/robin_set.h       |     6 +-
 .../ioss/src/heartbeat/Iohb_DatabaseIO.C      |    14 +-
 .../libraries/ioss/src/main/CMakeLists.txt    |     2 +-
 .../ioss/src/main/cth_pressure_map.C          |    14 +-
 .../libraries/ioss/src/main/io_shell_ts.C     |     6 +-
 .../libraries/ioss/src/main/shell_to_hex.C    |     6 +-
 .../ioss/src/pamgen/Iopg_DatabaseIO.C         |     2 +-
 .../libraries/ioss/src/utest/Utst_utils.C     |    35 +
 .../seacas/libraries/suplib_cpp/GetLongOpt.C  |    44 +-
 .../seacas/libraries/suplib_cpp/fmt/chrono.h  |  1129 +-
 .../seacas/libraries/suplib_cpp/fmt/color.h   |   795 +-
 .../seacas/libraries/suplib_cpp/fmt/compile.h |   730 +-
 .../seacas/libraries/suplib_cpp/fmt/core.h    |   112 +-
 .../libraries/suplib_cpp/fmt/format-inl.h     |  1969 +-
 .../seacas/libraries/suplib_cpp/fmt/format.h  |  5090 +--
 .../seacas/libraries/suplib_cpp/fmt/ostream.h |   198 +-
 .../seacas/libraries/suplib_cpp/fmt/printf.h  |   657 +-
 .../seacas/libraries/suplib_cpp/fmt/ranges.h  |   403 +-
 .../suplib_cpp/fmt/safe-duration-cast.h       |   445 +-
 packages/seacas/scripts/exodus3.in.py         |     4 +-
 packages/seacas/scripts/exomerge2.py          |    14 +-
 packages/seacas/scripts/exomerge3.py          |    94 +-
 81 files changed, 27593 insertions(+), 24016 deletions(-)
 create mode 100644 packages/seacas/libraries/aprepro_lib/stack.hh
 create mode 100644 packages/seacas/libraries/ioss/src/Ioss_Version.h

diff --git a/packages/seacas/applications/ejoin/EJ_SystemInterface.C b/packages/seacas/applications/ejoin/EJ_SystemInterface.C
index a2f886f162a7..d16d1891493a 100644
--- a/packages/seacas/applications/ejoin/EJ_SystemInterface.C
+++ b/packages/seacas/applications/ejoin/EJ_SystemInterface.C
@@ -15,19 +15,13 @@
 #include <vector>  // for vector
 
 namespace {
-  int case_strcmp(const std::string &s1, const std::string &s2)
+  bool str_equal(const std::string &s1, const std::string &s2)
   {
-    const char *c1 = s1.c_str();
-    const char *c2 = s2.c_str();
-    for (;; c1++, c2++) {
-      if (std::tolower(*c1) != std::tolower(*c2)) {
-        return (std::tolower(*c1) - std::tolower(*c2));
-      }
-      if (*c1 == '\0') {
-        return 0;
-      }
-    }
+    return (s1.size() == s2.size()) &&
+           std::equal(s1.begin(), s1.end(), s2.begin(),
+                      [](char a, char b) { return std::tolower(a) == std::tolower(b); });
   }
+
   void parse_variable_names(const char *tokens, StringIdVector *variable_list);
   void parse_variable_names(const char *tokens, StringIdVector *variable_list);
   void parse_offset(const char *tokens, vector3d *offset);
@@ -120,8 +114,8 @@ void SystemInterface::enroll_options()
 
   options_.enroll(
       "block_prefix", GetLongOption::MandatoryValue,
-      "Prefix used on the input block names of second and subsequent meshes to make them"
-      " unique.  Default is 'p'.  Example: block1, p1_block1, p2_block1.",
+      "Prefix used on the input block names of second and subsequent meshes to make them\n"
+      "\t\tunique.  Default is 'p'.  Example: block1, p1_block1, p2_block1.",
       "p");
 
   options_.enroll("offset", GetLongOption::MandatoryValue,
@@ -319,7 +313,7 @@ bool SystemInterface::parse_options(int argc, char **argv)
   {
     const char *temp = options_.retrieve("omit_nodesets");
     if (temp != nullptr) {
-      if (case_strcmp("ALL", temp) == 0) {
+      if (str_equal("ALL", temp)) {
         omitNodesets_ = true;
       }
       else {
@@ -334,7 +328,7 @@ bool SystemInterface::parse_options(int argc, char **argv)
   {
     const char *temp = options_.retrieve("omit_sidesets");
     if (temp != nullptr) {
-      if (case_strcmp("ALL", temp) == 0) {
+      if (str_equal("ALL", temp)) {
         omitSidesets_ = true;
       }
       else {
@@ -508,7 +502,7 @@ void SystemInterface::parse_step_option(const char *tokens)
       stepMax_      = abs(vals[1]);
       stepInterval_ = abs(vals[2]);
     }
-    else if (case_strcmp("LAST", tokens) == 0) {
+    else if (str_equal("LAST", tokens)) {
       stepMin_ = stepMax_ = -1;
     }
     else {
diff --git a/packages/seacas/applications/ejoin/EJoin.C b/packages/seacas/applications/ejoin/EJoin.C
index 8d62acb0d570..f183cdbb3074 100644
--- a/packages/seacas/applications/ejoin/EJoin.C
+++ b/packages/seacas/applications/ejoin/EJoin.C
@@ -1284,8 +1284,7 @@ namespace {
         continue;
       }
 
-      if (field_name != "ids" && (prefix.empty() || std::strncmp(prefix.c_str(), field_name.c_str(),
-                                                                 prefix.length()) == 0)) {
+      if (field_name != "ids" && Ioss::Utils::substr_equal(prefix, field_name)) {
         if (oge->field_exists(field_name)) {
           transfer_field_data_internal(ige, oge, field_name);
         }
@@ -1471,8 +1470,7 @@ namespace {
     // whose names begin with the prefix
     for (const auto &field_name : fields) {
       if (field_name != "ids" && !oge->field_exists(field_name) &&
-          (prefix.empty() ||
-           std::strncmp(prefix.c_str(), field_name.c_str(), prefix.length()) == 0)) {
+          Ioss::Utils::substr_equal(prefix, field_name)) {
         // If the field does not already exist, add it to the output node block
         Ioss::Field field = ige->get_field(field_name);
         oge->field_add(field);
diff --git a/packages/seacas/applications/epu/EP_ExodusEntity.h b/packages/seacas/applications/epu/EP_ExodusEntity.h
index 27b6bfc4c671..b4584c0440dd 100644
--- a/packages/seacas/applications/epu/EP_ExodusEntity.h
+++ b/packages/seacas/applications/epu/EP_ExodusEntity.h
@@ -52,11 +52,7 @@ namespace Excn {
   class Mesh
   {
   public:
-    Mesh()
-        : dimensionality(0), nodeCount(0), elementCount(0), blockCount(0), nodesetCount(0),
-          sidesetCount(0), needNodeMap(true), needElementMap(true)
-    {
-    }
+    Mesh() = default;
 
     size_t count(ObjectType type) const
     {
@@ -73,25 +69,20 @@ namespace Excn {
     IntVector truthTable[3];
 
     std::string title;
-    int         dimensionality;
-    int64_t     nodeCount;
-    int64_t     elementCount;
-    int         blockCount;
-    int         nodesetCount;
-    int         sidesetCount;
-    bool        needNodeMap;
-    bool        needElementMap;
+    int         dimensionality{0};
+    int64_t     nodeCount{0};
+    int64_t     elementCount{0};
+    int         blockCount{0};
+    int         nodesetCount{0};
+    int         sidesetCount{0};
+    bool        needNodeMap{true};
+    bool        needElementMap{true};
   };
 
   class Block
   {
   public:
-    Block()
-        : name_(""), id(0), elementCount(0), nodesPerElement(0), attributeCount(0), offset_(0),
-          position_(0)
-    {
-      copy_string(elType, "");
-    }
+    Block() { copy_string(elType, ""); }
 
     Block(const Block &other)
         : name_(other.name_), id(other.id), elementCount(other.elementCount),
@@ -106,14 +97,14 @@ namespace Excn {
     size_t entity_count() const { return elementCount; }
 
     char                     elType[MAX_STR_LENGTH + 1]{};
-    std::string              name_;
+    std::string              name_{""};
     std::vector<std::string> attributeNames;
-    int64_t                  id;
-    int64_t                  elementCount;
-    int                      nodesPerElement;
-    int                      attributeCount;
-    int64_t                  offset_;
-    int                      position_;
+    int64_t                  id{0};
+    int64_t                  elementCount{0};
+    int                      nodesPerElement{0};
+    int                      attributeCount{0};
+    int64_t                  offset_{0};
+    int                      position_{0};
 
     Block &operator=(const Block &other)
     {
@@ -133,14 +124,14 @@ namespace Excn {
   template <typename INT> class NodeSet
   {
   public:
-    NodeSet() : id(0), nodeCount(0), dfCount(0), offset_(0), position_(-1), name_("") {}
+    NodeSet() = default;
 
-    ex_entity_id id;
-    int64_t      nodeCount;
-    int64_t      dfCount;
-    int64_t      offset_;
-    int          position_;
-    std::string  name_;
+    ex_entity_id id{0};
+    int64_t      nodeCount{0};
+    int64_t      dfCount{0};
+    int64_t      offset_{0};
+    int          position_{-1};
+    std::string  name_{""};
 
     std::vector<INT> nodeSetNodes;
     std::vector<INT> nodeOrderMap;
@@ -193,39 +184,35 @@ namespace Excn {
   class CommunicationMap
   {
   public:
-    CommunicationMap() : id(0), entityCount(0), type('U') {}
+    CommunicationMap() = default;
     CommunicationMap(int the_id, int64_t count, char the_type)
         : id(the_id), entityCount(count), type(the_type)
     {
     }
-    int64_t id;
-    int64_t entityCount;
-    char    type; // 'n' for node, 'e' for element
+    int64_t id{0};
+    int64_t entityCount{0};
+    char    type{'U'}; // 'n' for node, 'e' for element
   };
 
   class CommunicationMetaData
   {
   public:
-    CommunicationMetaData()
-        : processorId(0), processorCount(0), globalNodes(0), globalElements(0), nodesInternal(0),
-          nodesBorder(0), nodesExternal(0), elementsInternal(0), elementsBorder(0)
-    {
-    }
+    CommunicationMetaData()                              = default;
     CommunicationMetaData(const CommunicationMetaData &) = delete;
     CommunicationMetaData &operator=(const CommunicationMetaData &other) = delete;
 
     std::vector<CommunicationMap> nodeMap;
     std::vector<CommunicationMap> elementMap;
 
-    int     processorId;
-    int     processorCount;
-    int64_t globalNodes;
-    int64_t globalElements;
-    int64_t nodesInternal;
-    int64_t nodesBorder;
-    int64_t nodesExternal;
-    int64_t elementsInternal;
-    int64_t elementsBorder;
+    int     processorId{0};
+    int     processorCount{0};
+    int64_t globalNodes{0};
+    int64_t globalElements{0};
+    int64_t nodesInternal{0};
+    int64_t nodesBorder{0};
+    int64_t nodesExternal{0};
+    int64_t elementsInternal{0};
+    int64_t elementsBorder{0};
   };
 } // namespace Excn
 #endif /* SEACAS_ExodusEntity_H */
diff --git a/packages/seacas/applications/epu/EP_SystemInterface.C b/packages/seacas/applications/epu/EP_SystemInterface.C
index 0653238530a1..f27dc138ef79 100644
--- a/packages/seacas/applications/epu/EP_SystemInterface.C
+++ b/packages/seacas/applications/epu/EP_SystemInterface.C
@@ -51,19 +51,13 @@
 #include <vector>  // for vector
 
 namespace {
-  int case_strcmp(const std::string &s1, const std::string &s2)
+  bool str_equal(const std::string &s1, const std::string &s2)
   {
-    const char *c1 = s1.c_str();
-    const char *c2 = s2.c_str();
-    for (;; c1++, c2++) {
-      if (std::tolower(*c1) != std::tolower(*c2)) {
-        return (std::tolower(*c1) - std::tolower(*c2));
-      }
-      if (*c1 == '\0') {
-        return 0;
-      }
-    }
+    return (s1.size() == s2.size()) &&
+           std::equal(s1.begin(), s1.end(), s2.begin(),
+                      [](char a, char b) { return std::tolower(a) == std::tolower(b); });
   }
+
   void parse_variable_names(const char *tokens, Excn::StringIdVector *variable_list);
 } // namespace
 
@@ -163,7 +157,7 @@ void Excn::SystemInterface::enroll_options()
 
   options_.enroll("join_subcycles", GetLongOption::NoValue,
                   "If -subcycle is specified, then after the subcycle files are processed,\n"
-                  "\t\turn epu one more time and join the subcycle files into a single file.",
+                  "\t\trun epu one more time and join the subcycle files into a single file.",
                   nullptr);
 
   options_.enroll("keep_temporary", GetLongOption::NoValue,
@@ -507,6 +501,19 @@ bool Excn::SystemInterface::parse_options(int argc, char **argv)
   else {
     throw std::runtime_error("\nERROR: (EPU) basename not specified\n");
   }
+
+  // Check that subcycle count does not match processor count --
+  // in that case the existing files will be overwritten.
+  if (processorCount_ <= subcycle_) {
+    if (myRank_ == 0) {
+      fmt::print(stderr,
+                 "\nERROR: (EPU) Invalid subcycle count specified: '{}'."
+                 "\n             Must be less than processor count '{}'.\n\n",
+                 subcycle_, processorCount_);
+    }
+    return false;
+  }
+
   return true;
 }
 
@@ -581,7 +588,7 @@ void Excn::SystemInterface::parse_step_option(const char *tokens)
       stepMax_      = abs(vals[1]);
       stepInterval_ = abs(vals[2]);
     }
-    else if (case_strcmp("LAST", tokens) == 0) {
+    else if (str_equal("LAST", tokens)) {
       stepMin_ = stepMax_ = -1;
     }
     else {
diff --git a/packages/seacas/applications/exodiff/ED_SystemInterface.C b/packages/seacas/applications/exodiff/ED_SystemInterface.C
index c005c11cd929..3a4f0d12157a 100644
--- a/packages/seacas/applications/exodiff/ED_SystemInterface.C
+++ b/packages/seacas/applications/exodiff/ED_SystemInterface.C
@@ -30,19 +30,13 @@ namespace {
                               Tolerance &def_tol, std::vector<std::string> &names,
                               std::vector<Tolerance> &toler, int max_names);
 
-  int case_strcmp(const std::string &s1, const std::string &s2)
+  bool str_equal(const std::string &s1, const std::string &s2)
   {
-    const char *c1 = s1.c_str();
-    const char *c2 = s2.c_str();
-    for (;; c1++, c2++) {
-      if (std::tolower(*c1) != std::tolower(*c2)) {
-        return (std::tolower(*c1) - std::tolower(*c2));
-      }
-      if (*c1 == '\0') {
-        return 0;
-      }
-    }
+    return (s1.size() == s2.size()) &&
+           std::equal(s1.begin(), s1.end(), s2.begin(),
+                      [](char a, char b) { return std::tolower(a) == std::tolower(b); });
   }
+
   void file_help();
   void tolerance_help();
 
@@ -377,7 +371,7 @@ void SystemInterface::enroll_options()
                   nullptr);
   options_.enroll("short", GetLongOption::NoValue,
                   "Short block type compare.  Forces element block type strings to\n"
-                  "\t\the compared only up to the shortest string length.  For example,\n"
+                  "\t\tbe compared only up to the shortest string length.  For example,\n"
                   "\t\t\"HEX\" and \"HEX8\" will be considered the same. (default)",
                   nullptr);
   options_.enroll("no_short", GetLongOption::NoValue,
@@ -409,7 +403,7 @@ void SystemInterface::enroll_options()
                   "True if forcing the use of 64-bit integers for the output file", nullptr);
   options_.enroll("nosymmetric_name_check", GetLongOption::NoValue,
                   "No symmetric variable name checking.  By default, a warning will\n"
-                  "\t\the produced if a name that is not to be excluded is contained\n"
+                  "\t\tbe produced if a name that is not to be excluded is contained\n"
                   "\t\tin the second file given on the command line but not the first.\n"
                   "\t\tThis \"symmetric\" check can be turned off with this option.",
                   nullptr);
@@ -512,13 +506,13 @@ bool SystemInterface::parse_options(int argc, char **argv)
   {
     const char *temp = options_.retrieve("help");
     if (temp != nullptr) {
-      if ((case_strcmp("usage", temp) == 0) || (case_strcmp("all", temp) == 0)) {
+      if ((str_equal("usage", temp)) || (str_equal("all", temp))) {
         options_.usage();
       }
-      if ((case_strcmp("file", temp) == 0) || (case_strcmp("all", temp) == 0)) {
+      if ((str_equal("file", temp)) || (str_equal("all", temp))) {
         file_help();
       }
-      if ((case_strcmp("tolerance", temp) == 0) || (case_strcmp("all", temp) == 0)) {
+      if ((str_equal("tolerance", temp)) || (str_equal("all", temp))) {
         tolerance_help();
       }
       fmt::print("\n\t\tCan also set options via EXODIFF_OPTIONS environment variable.\n");
@@ -659,7 +653,7 @@ bool SystemInterface::parse_options(int argc, char **argv)
       // (1-based) or 'last'
       std::vector<std::string> tokens = SLIB::tokenize(temp, ":");
       if (tokens.size() == 2) {
-        if (case_strcmp(tokens[0], "last") == 0) {
+        if (str_equal(tokens[0], "last")) {
           explicit_steps.first = -1;
         }
         else {
@@ -667,7 +661,7 @@ bool SystemInterface::parse_options(int argc, char **argv)
           explicit_steps.first = std::stoi(tokens[0]);
         }
 
-        if (case_strcmp(tokens[1], "last") == 0) {
+        if (str_equal(tokens[1], "last")) {
           explicit_steps.second = -1;
         }
         else {
diff --git a/packages/seacas/applications/nem_spread/el_exoII_io.C b/packages/seacas/applications/nem_spread/el_exoII_io.C
index d4f5edec7ceb..e33f954cb558 100644
--- a/packages/seacas/applications/nem_spread/el_exoII_io.C
+++ b/packages/seacas/applications/nem_spread/el_exoII_io.C
@@ -1797,6 +1797,9 @@ void NemSpread<T, INT>::find_elem_block(INT *proc_elem_blk, int iproc, int /*pro
    *                              the global element block number.
    *                              (Global int vector of length globals.Num_Elem_Blk)
    */
+  if (globals.Num_Elem_Blk == 0) {
+    return;
+  }
 
   /* Boolean vector of length globals.Num_Elem_Blk If the i'th
      element block exists on the current processor, the i'th entry
diff --git a/packages/seacas/applications/slice/SL_SystemInterface.C b/packages/seacas/applications/slice/SL_SystemInterface.C
index 0733e9542395..afe2a63c741e 100644
--- a/packages/seacas/applications/slice/SL_SystemInterface.C
+++ b/packages/seacas/applications/slice/SL_SystemInterface.C
@@ -53,19 +53,13 @@
 #endif
 
 namespace {
-  int case_strcmp(const std::string &s1, const std::string &s2)
+  bool str_equal(const std::string &s1, const std::string &s2)
   {
-    const char *c1 = s1.c_str();
-    const char *c2 = s2.c_str();
-    for (;; c1++, c2++) {
-      if (std::tolower(*c1) != std::tolower(*c2)) {
-        return (std::tolower(*c1) - std::tolower(*c2));
-      }
-      if (*c1 == '\0') {
-        return 0;
-      }
-    }
+    return (s1.size() == s2.size()) &&
+           std::equal(s1.begin(), s1.end(), s2.begin(),
+                      [](char a, char b) { return std::tolower(a) == std::tolower(b); });
   }
+
 #if 0
   void parse_variable_names(const char *tokens, StringIdVector *variable_list);
   void parse_integer_list(const char *tokens, std::vector<int> *list);
@@ -373,7 +367,7 @@ void SystemInterface::parse_step_option(const char *tokens)
       stepMax_      = abs(vals[1]);
       stepInterval_ = abs(vals[2]);
     }
-    else if (case_strcmp("LAST", tokens) == 0) {
+    else if (str_equal("LAST", tokens)) {
       stepMin_ = stepMax_ = -1;
     }
     else {
diff --git a/packages/seacas/format.sh b/packages/seacas/format.sh
index 345c69bdb72b..b680144c2757 100755
--- a/packages/seacas/format.sh
+++ b/packages/seacas/format.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-for i in $(ls *.[cCh]); do
+for i in $(ls ./*.[cCh]); do
     echo $i
     clang-format -style=file $i > tmp
     mv tmp $i
diff --git a/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc b/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc
index 7afc2a79186d..921727a4cd0e 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc
@@ -51,7 +51,7 @@
 
 namespace {
   const unsigned int HASHSIZE       = 5939;
-  const char *       version_string = "5.12 (2019/08/21)";
+  const char *       version_string = "5.13 (2019/10/17)";
 
   void output_copyright();
 
@@ -520,7 +520,7 @@ namespace SEAMS {
           << "  --comment=char or -c=char: Change comment character to 'char'      \n"
           << "      --copyright or -C: Print copyright message                 \n"
           << "   --keep_history or -k: Keep a history of aprepro substitutions.\n"
-	  << "                         (not for general interactive use)       \n"
+          << "                         (not for general interactive use)       \n"
           << "          --quiet or -q: (deprecated, option is ignored)         \n"
           << "                var=val: Assign value 'val' to variable 'var'    \n"
           << "                         Use var=\\\"sval\\\" for a string variable\n\n"
diff --git a/packages/seacas/libraries/aprepro_lib/apr_builtin.cc b/packages/seacas/libraries/aprepro_lib/apr_builtin.cc
index 8152bf5465ac..6005dd21e249 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_builtin.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_builtin.cc
@@ -1064,6 +1064,7 @@ namespace SEAMS {
         }
       }
       assert(rows - rows_to_skip == (size_t)array_data->rows);
+      delete file;
       return array_data;
     }
 
@@ -1111,9 +1112,9 @@ namespace SEAMS {
         }
       }
       assert((int)rows == array_data->rows);
+      delete file;
       return array_data;
     }
-
     return nullptr;
   }
 
diff --git a/packages/seacas/libraries/aprepro_lib/apr_exodus.cc b/packages/seacas/libraries/aprepro_lib/apr_exodus.cc
index fc094de21b39..4474137c2eb7 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_exodus.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_exodus.cc
@@ -257,7 +257,7 @@ namespace SEAMS {
 
       int64_t idx = 0;
       for (int64_t i = 0; i < num_elemblks; i++) {
-        ex_get_block(exoid, EX_ELEM_BLOCK, ids[i], type, &nel, &nnel, 0, 0, &natr);
+        ex_get_block(exoid, EX_ELEM_BLOCK, ids[i], type, &nel, &nnel, nullptr, nullptr, &natr);
         array_data->data[i]           = ids[i];
         array_block_info->data[idx++] = ids[i];
         array_block_info->data[idx++] = nel;
diff --git a/packages/seacas/libraries/aprepro_lib/apr_parser.cc b/packages/seacas/libraries/aprepro_lib/apr_parser.cc
index 3f129a5788d0..3b17fd46d051 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_parser.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_parser.cc
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.3.2.
+// A Bison parser, made by GNU Bison 3.4.
 
 // Skeleton implementation for Bison LALR(1) parsers in C++
 
@@ -37,7 +37,7 @@
 #define yylex SEAMSlex
 
 // First part of user prologue.
-#line 33 "aprepro.yy" // lalr1.cc:429
+#line 33 "aprepro.yy"
 
 #include "apr_array.h"
 #include "apr_util.h"
@@ -67,12 +67,12 @@ namespace SEAMS {
   extern bool echo;
 }
 
-#line 74 "apr_parser.cc" // lalr1.cc:429
+#line 74 "apr_parser.cc"
 
 #include "aprepro_parser.h"
 
 // Second part of user prologue.
-#line 130 "aprepro.yy" // lalr1.cc:434
+#line 130 "aprepro.yy"
 
 #include "apr_scanner.h"
 #include "aprepro.h"
@@ -83,7 +83,7 @@ namespace SEAMS {
 #undef yylex
 #define yylex aprepro.lexer->lex
 
-#line 92 "apr_parser.cc" // lalr1.cc:434
+#line 93 "apr_parser.cc"
 
 #ifndef YY_
 #if defined YYENABLE_NLS && YYENABLE_NLS
@@ -158,7 +158,7 @@ namespace SEAMS {
 #define YYRECOVERING() (!!yyerrstatus_)
 
 namespace SEAMS {
-#line 168 "apr_parser.cc" // lalr1.cc:510
+#line 169 "apr_parser.cc"
 
   /* Return YYSTR after stripping away unnecessary quotes and
      backslashes, so that it's suitable for yyerror.  The heuristic is
@@ -524,16 +524,16 @@ namespace SEAMS {
         {
           switch (yyn) {
           case 4:
-#line 149 "aprepro.yy" // lalr1.cc:919
+#line 149 "aprepro.yy"
           {
             if (echo)
               aprepro.lexer->LexerOutput("\n", 1);
           }
-#line 636 "apr_parser.cc" // lalr1.cc:919
+#line 638 "apr_parser.cc"
           break;
 
           case 5:
-#line 150 "aprepro.yy" // lalr1.cc:919
+#line 150 "aprepro.yy"
           {
             if (echo) {
               static char    tmpstr[512];
@@ -542,202 +542,202 @@ namespace SEAMS {
               aprepro.lexer->LexerOutput(tmpstr, len);
             }
           }
-#line 648 "apr_parser.cc" // lalr1.cc:919
+#line 650 "apr_parser.cc"
           break;
 
           case 6:
-#line 157 "aprepro.yy" // lalr1.cc:919
+#line 157 "aprepro.yy"
           {
             if (echo && (yystack_[1].value.string) != NULL) {
               aprepro.lexer->LexerOutput((yystack_[1].value.string),
                                          strlen((yystack_[1].value.string)));
             }
           }
-#line 657 "apr_parser.cc" // lalr1.cc:919
+#line 659 "apr_parser.cc"
           break;
 
           case 7:
-#line 161 "aprepro.yy" // lalr1.cc:919
+#line 161 "aprepro.yy"
           {
           }
-#line 663 "apr_parser.cc" // lalr1.cc:919
+#line 665 "apr_parser.cc"
           break;
 
           case 8:
-#line 162 "aprepro.yy" // lalr1.cc:919
+#line 162 "aprepro.yy"
           {
           }
-#line 669 "apr_parser.cc" // lalr1.cc:919
+#line 671 "apr_parser.cc"
           break;
 
           case 9:
-#line 163 "aprepro.yy" // lalr1.cc:919
+#line 163 "aprepro.yy"
           {
             yyerrok;
           }
-#line 675 "apr_parser.cc" // lalr1.cc:919
+#line 677 "apr_parser.cc"
           break;
 
           case 10:
-#line 166 "aprepro.yy" // lalr1.cc:919
+#line 166 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) < (yystack_[0].value.val);
           }
-#line 681 "apr_parser.cc" // lalr1.cc:919
+#line 683 "apr_parser.cc"
           break;
 
           case 11:
-#line 167 "aprepro.yy" // lalr1.cc:919
+#line 167 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) > (yystack_[0].value.val);
           }
-#line 687 "apr_parser.cc" // lalr1.cc:919
+#line 689 "apr_parser.cc"
           break;
 
           case 12:
-#line 168 "aprepro.yy" // lalr1.cc:919
+#line 168 "aprepro.yy"
           {
             (yylhs.value.val) = !((yystack_[0].value.val));
           }
-#line 693 "apr_parser.cc" // lalr1.cc:919
+#line 695 "apr_parser.cc"
           break;
 
           case 13:
-#line 169 "aprepro.yy" // lalr1.cc:919
+#line 169 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) <= (yystack_[0].value.val);
           }
-#line 699 "apr_parser.cc" // lalr1.cc:919
+#line 701 "apr_parser.cc"
           break;
 
           case 14:
-#line 170 "aprepro.yy" // lalr1.cc:919
+#line 170 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) >= (yystack_[0].value.val);
           }
-#line 705 "apr_parser.cc" // lalr1.cc:919
+#line 707 "apr_parser.cc"
           break;
 
           case 15:
-#line 171 "aprepro.yy" // lalr1.cc:919
+#line 171 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) == (yystack_[0].value.val);
           }
-#line 711 "apr_parser.cc" // lalr1.cc:919
+#line 713 "apr_parser.cc"
           break;
 
           case 16:
-#line 172 "aprepro.yy" // lalr1.cc:919
+#line 172 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) != (yystack_[0].value.val);
           }
-#line 717 "apr_parser.cc" // lalr1.cc:919
+#line 719 "apr_parser.cc"
           break;
 
           case 17:
-#line 173 "aprepro.yy" // lalr1.cc:919
+#line 173 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) || (yystack_[0].value.val);
           }
-#line 723 "apr_parser.cc" // lalr1.cc:919
+#line 725 "apr_parser.cc"
           break;
 
           case 18:
-#line 174 "aprepro.yy" // lalr1.cc:919
+#line 174 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) && (yystack_[0].value.val);
           }
-#line 729 "apr_parser.cc" // lalr1.cc:919
+#line 731 "apr_parser.cc"
           break;
 
           case 19:
-#line 175 "aprepro.yy" // lalr1.cc:919
+#line 175 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) || (yystack_[0].value.val);
           }
-#line 735 "apr_parser.cc" // lalr1.cc:919
+#line 737 "apr_parser.cc"
           break;
 
           case 20:
-#line 176 "aprepro.yy" // lalr1.cc:919
+#line 176 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) && (yystack_[0].value.val);
           }
-#line 741 "apr_parser.cc" // lalr1.cc:919
+#line 743 "apr_parser.cc"
           break;
 
           case 21:
-#line 177 "aprepro.yy" // lalr1.cc:919
+#line 177 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[1].value.val);
           }
-#line 747 "apr_parser.cc" // lalr1.cc:919
+#line 749 "apr_parser.cc"
           break;
 
           case 22:
-#line 180 "aprepro.yy" // lalr1.cc:919
+#line 180 "aprepro.yy"
           {
             (yylhs.value.val) =
                 (strcmp((yystack_[2].value.string), (yystack_[0].value.string)) < 0 ? 1 : 0);
           }
-#line 753 "apr_parser.cc" // lalr1.cc:919
+#line 755 "apr_parser.cc"
           break;
 
           case 23:
-#line 181 "aprepro.yy" // lalr1.cc:919
+#line 181 "aprepro.yy"
           {
             (yylhs.value.val) =
                 (strcmp((yystack_[2].value.string), (yystack_[0].value.string)) > 0 ? 1 : 0);
           }
-#line 759 "apr_parser.cc" // lalr1.cc:919
+#line 761 "apr_parser.cc"
           break;
 
           case 24:
-#line 182 "aprepro.yy" // lalr1.cc:919
+#line 182 "aprepro.yy"
           {
             (yylhs.value.val) =
                 (strcmp((yystack_[2].value.string), (yystack_[0].value.string)) <= 0 ? 1 : 0);
           }
-#line 765 "apr_parser.cc" // lalr1.cc:919
+#line 767 "apr_parser.cc"
           break;
 
           case 25:
-#line 183 "aprepro.yy" // lalr1.cc:919
+#line 183 "aprepro.yy"
           {
             (yylhs.value.val) =
                 (strcmp((yystack_[2].value.string), (yystack_[0].value.string)) >= 0 ? 1 : 0);
           }
-#line 771 "apr_parser.cc" // lalr1.cc:919
+#line 773 "apr_parser.cc"
           break;
 
           case 26:
-#line 184 "aprepro.yy" // lalr1.cc:919
+#line 184 "aprepro.yy"
           {
             (yylhs.value.val) =
                 (strcmp((yystack_[2].value.string), (yystack_[0].value.string)) == 0 ? 1 : 0);
           }
-#line 777 "apr_parser.cc" // lalr1.cc:919
+#line 779 "apr_parser.cc"
           break;
 
           case 27:
-#line 185 "aprepro.yy" // lalr1.cc:919
+#line 185 "aprepro.yy"
           {
             (yylhs.value.val) =
                 (strcmp((yystack_[2].value.string), (yystack_[0].value.string)) != 0 ? 1 : 0);
           }
-#line 783 "apr_parser.cc" // lalr1.cc:919
+#line 785 "apr_parser.cc"
           break;
 
           case 28:
-#line 187 "aprepro.yy" // lalr1.cc:919
+#line 187 "aprepro.yy"
           {
             (yylhs.value.arrval) = (yystack_[0].value.tptr)->value.avar;
           }
-#line 789 "apr_parser.cc" // lalr1.cc:919
+#line 791 "apr_parser.cc"
           break;
 
           case 29:
-#line 188 "aprepro.yy" // lalr1.cc:919
+#line 188 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.arrfnct_c == NULL))
@@ -746,11 +746,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 800 "apr_parser.cc" // lalr1.cc:919
+#line 802 "apr_parser.cc"
           break;
 
           case 30:
-#line 194 "aprepro.yy" // lalr1.cc:919
+#line 194 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.arrfnct_cd == NULL))
@@ -759,11 +759,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 811 "apr_parser.cc" // lalr1.cc:919
+#line 813 "apr_parser.cc"
           break;
 
           case 31:
-#line 200 "aprepro.yy" // lalr1.cc:919
+#line 200 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.arrfnct_cc == NULL))
@@ -772,11 +772,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 822 "apr_parser.cc" // lalr1.cc:919
+#line 824 "apr_parser.cc"
           break;
 
           case 32:
-#line 206 "aprepro.yy" // lalr1.cc:919
+#line 206 "aprepro.yy"
           {
             if (arg_check((yystack_[7].value.tptr),
                           (yystack_[7].value.tptr)->value.arrfnct_ddd == NULL))
@@ -785,11 +785,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 833 "apr_parser.cc" // lalr1.cc:919
+#line 835 "apr_parser.cc"
           break;
 
           case 33:
-#line 212 "aprepro.yy" // lalr1.cc:919
+#line 212 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.arrfnct_dd == NULL))
@@ -798,11 +798,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 844 "apr_parser.cc" // lalr1.cc:919
+#line 846 "apr_parser.cc"
           break;
 
           case 34:
-#line 218 "aprepro.yy" // lalr1.cc:919
+#line 218 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.arrfnct_d == NULL))
@@ -811,11 +811,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 855 "apr_parser.cc" // lalr1.cc:919
+#line 857 "apr_parser.cc"
           break;
 
           case 35:
-#line 224 "aprepro.yy" // lalr1.cc:919
+#line 224 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.arrfnct_a == NULL))
@@ -824,33 +824,55 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 866 "apr_parser.cc" // lalr1.cc:919
+#line 868 "apr_parser.cc"
           break;
 
           case 36:
-#line 230 "aprepro.yy" // lalr1.cc:919
+#line 230 "aprepro.yy"
           {
-            (yylhs.value.arrval) = (yystack_[0].value.arrval);
-            delete (yystack_[2].value.tptr)->value.avar;
+            (yylhs.value.arrval)                 = (yystack_[0].value.arrval);
             (yystack_[2].value.tptr)->value.avar = (yystack_[0].value.arrval);
             redefined_warning(aprepro, (yystack_[2].value.tptr));
             set_type(aprepro, (yystack_[2].value.tptr), token::AVAR);
           }
-#line 874 "apr_parser.cc" // lalr1.cc:919
+#line 877 "apr_parser.cc"
           break;
 
           case 37:
-#line 233 "aprepro.yy" // lalr1.cc:919
+#line 234 "aprepro.yy"
           {
             (yylhs.value.arrval)                 = (yystack_[0].value.arrval);
             (yystack_[2].value.tptr)->value.avar = (yystack_[0].value.arrval);
+            redefined_warning(aprepro, (yystack_[2].value.tptr));
             set_type(aprepro, (yystack_[2].value.tptr), token::AVAR);
           }
-#line 881 "apr_parser.cc" // lalr1.cc:919
+#line 886 "apr_parser.cc"
           break;
 
           case 38:
-#line 235 "aprepro.yy" // lalr1.cc:919
+#line 238 "aprepro.yy"
+          {
+            (yylhs.value.arrval) = (yystack_[0].value.arrval);
+            delete (yystack_[2].value.tptr)->value.avar;
+            (yystack_[2].value.tptr)->value.avar = (yystack_[0].value.arrval);
+            redefined_warning(aprepro, (yystack_[2].value.tptr));
+            set_type(aprepro, (yystack_[2].value.tptr), token::AVAR);
+          }
+#line 894 "apr_parser.cc"
+          break;
+
+          case 39:
+#line 241 "aprepro.yy"
+          {
+            (yylhs.value.arrval)                 = (yystack_[0].value.arrval);
+            (yystack_[2].value.tptr)->value.avar = (yystack_[0].value.arrval);
+            set_type(aprepro, (yystack_[2].value.tptr), token::AVAR);
+          }
+#line 901 "apr_parser.cc"
+          break;
+
+          case 40:
+#line 243 "aprepro.yy"
           {
             if ((yystack_[2].value.arrval)->cols == (yystack_[0].value.arrval)->cols &&
                 (yystack_[2].value.arrval)->rows == (yystack_[0].value.arrval)->rows) {
@@ -862,19 +884,19 @@ namespace SEAMS {
               yyerrok;
             }
           }
-#line 894 "apr_parser.cc" // lalr1.cc:919
+#line 914 "apr_parser.cc"
           break;
 
-          case 39:
-#line 243 "aprepro.yy" // lalr1.cc:919
+          case 41:
+#line 251 "aprepro.yy"
           {
             (yylhs.value.arrval) = array_scale((yystack_[0].value.arrval), -1.0);
           }
-#line 900 "apr_parser.cc" // lalr1.cc:919
+#line 920 "apr_parser.cc"
           break;
 
-          case 40:
-#line 245 "aprepro.yy" // lalr1.cc:919
+          case 42:
+#line 253 "aprepro.yy"
           {
             if ((yystack_[2].value.arrval)->cols == (yystack_[0].value.arrval)->cols &&
                 (yystack_[2].value.arrval)->rows == (yystack_[0].value.arrval)->rows) {
@@ -886,36 +908,36 @@ namespace SEAMS {
               yyerrok;
             }
           }
-#line 913 "apr_parser.cc" // lalr1.cc:919
+#line 933 "apr_parser.cc"
           break;
 
-          case 41:
-#line 253 "aprepro.yy" // lalr1.cc:919
+          case 43:
+#line 261 "aprepro.yy"
           {
             (yylhs.value.arrval) = array_scale((yystack_[2].value.arrval), (yystack_[0].value.val));
           }
-#line 919 "apr_parser.cc" // lalr1.cc:919
+#line 939 "apr_parser.cc"
           break;
 
-          case 42:
-#line 254 "aprepro.yy" // lalr1.cc:919
+          case 44:
+#line 262 "aprepro.yy"
           {
             (yylhs.value.arrval) =
                 array_scale((yystack_[2].value.arrval), 1.0 / (yystack_[0].value.val));
           }
-#line 925 "apr_parser.cc" // lalr1.cc:919
+#line 945 "apr_parser.cc"
           break;
 
-          case 43:
-#line 255 "aprepro.yy" // lalr1.cc:919
+          case 45:
+#line 263 "aprepro.yy"
           {
             (yylhs.value.arrval) = array_scale((yystack_[0].value.arrval), (yystack_[2].value.val));
           }
-#line 931 "apr_parser.cc" // lalr1.cc:919
+#line 951 "apr_parser.cc"
           break;
 
-          case 44:
-#line 256 "aprepro.yy" // lalr1.cc:919
+          case 46:
+#line 264 "aprepro.yy"
           {
             if ((yystack_[2].value.arrval)->cols == (yystack_[0].value.arrval)->rows) {
               (yylhs.value.arrval) =
@@ -927,84 +949,96 @@ namespace SEAMS {
               yyerrok;
             }
           }
-#line 944 "apr_parser.cc" // lalr1.cc:919
+#line 964 "apr_parser.cc"
           break;
 
-          case 45:
-#line 265 "aprepro.yy" // lalr1.cc:919
+          case 47:
+#line 273 "aprepro.yy"
           {
             (yylhs.value.string) = (yystack_[0].value.string);
           }
-#line 950 "apr_parser.cc" // lalr1.cc:919
+#line 970 "apr_parser.cc"
           break;
 
-          case 46:
-#line 266 "aprepro.yy" // lalr1.cc:919
+          case 48:
+#line 274 "aprepro.yy"
           {
             (yylhs.value.string) = (char *)(yystack_[0].value.tptr)->value.svar.c_str();
           }
-#line 956 "apr_parser.cc" // lalr1.cc:919
+#line 976 "apr_parser.cc"
           break;
 
-          case 47:
-#line 267 "aprepro.yy" // lalr1.cc:919
+          case 49:
+#line 275 "aprepro.yy"
           {
             (yylhs.value.string) = (char *)(yystack_[0].value.tptr)->value.svar.c_str();
           }
-#line 962 "apr_parser.cc" // lalr1.cc:919
+#line 982 "apr_parser.cc"
           break;
 
-          case 48:
-#line 268 "aprepro.yy" // lalr1.cc:919
+          case 50:
+#line 276 "aprepro.yy"
           {
             (yylhs.value.string)                 = (yystack_[0].value.string);
             (yystack_[2].value.tptr)->value.svar = (yystack_[0].value.string);
             set_type(aprepro, (yystack_[2].value.tptr), Parser::token::SVAR);
           }
-#line 969 "apr_parser.cc" // lalr1.cc:919
+#line 989 "apr_parser.cc"
           break;
 
-          case 49:
-#line 270 "aprepro.yy" // lalr1.cc:919
+          case 51:
+#line 278 "aprepro.yy"
           {
             (yylhs.value.string)                 = (yystack_[0].value.string);
             (yystack_[2].value.tptr)->value.svar = (yystack_[0].value.string);
             redefined_warning(aprepro, (yystack_[2].value.tptr));
           }
-#line 977 "apr_parser.cc" // lalr1.cc:919
+#line 997 "apr_parser.cc"
           break;
 
-          case 50:
-#line 273 "aprepro.yy" // lalr1.cc:919
+          case 52:
+#line 281 "aprepro.yy"
           {
             (yylhs.value.string)                 = (yystack_[0].value.string);
             (yystack_[2].value.tptr)->value.svar = (yystack_[0].value.string);
             redefined_warning(aprepro, (yystack_[2].value.tptr));
             set_type(aprepro, (yystack_[2].value.tptr), token::SVAR);
           }
-#line 986 "apr_parser.cc" // lalr1.cc:919
+#line 1006 "apr_parser.cc"
           break;
 
-          case 51:
-#line 277 "aprepro.yy" // lalr1.cc:919
+          case 53:
+#line 285 "aprepro.yy"
+          {
+            (yylhs.value.string) = (yystack_[0].value.string);
+            delete (yystack_[2].value.tptr)->value.avar;
+            (yystack_[2].value.tptr)->value.svar = (yystack_[0].value.string);
+            redefined_warning(aprepro, (yystack_[2].value.tptr));
+            set_type(aprepro, (yystack_[2].value.tptr), token::SVAR);
+          }
+#line 1016 "apr_parser.cc"
+          break;
+
+          case 54:
+#line 290 "aprepro.yy"
           {
             (yylhs.value.string) = (char *)(yystack_[2].value.tptr)->value.svar.c_str();
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 992 "apr_parser.cc" // lalr1.cc:919
+#line 1022 "apr_parser.cc"
           break;
 
-          case 52:
-#line 278 "aprepro.yy" // lalr1.cc:919
+          case 55:
+#line 291 "aprepro.yy"
           {
             immutable_modify(aprepro, (yystack_[2].value.tptr));
             YYERROR;
           }
-#line 998 "apr_parser.cc" // lalr1.cc:919
+#line 1028 "apr_parser.cc"
           break;
 
-          case 53:
-#line 279 "aprepro.yy" // lalr1.cc:919
+          case 56:
+#line 292 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.strfnct_c == NULL))
@@ -1013,11 +1047,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1009 "apr_parser.cc" // lalr1.cc:919
+#line 1039 "apr_parser.cc"
           break;
 
-          case 54:
-#line 285 "aprepro.yy" // lalr1.cc:919
+          case 57:
+#line 298 "aprepro.yy"
           {
             if (arg_check((yystack_[2].value.tptr),
                           (yystack_[2].value.tptr)->value.strfnct == NULL))
@@ -1025,11 +1059,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1020 "apr_parser.cc" // lalr1.cc:919
+#line 1050 "apr_parser.cc"
           break;
 
-          case 55:
-#line 291 "aprepro.yy" // lalr1.cc:919
+          case 58:
+#line 304 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.strfnct_d == NULL))
@@ -1038,11 +1072,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1031 "apr_parser.cc" // lalr1.cc:919
+#line 1061 "apr_parser.cc"
           break;
 
-          case 56:
-#line 297 "aprepro.yy" // lalr1.cc:919
+          case 59:
+#line 310 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.strfnct_a == NULL))
@@ -1051,20 +1085,20 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1042 "apr_parser.cc" // lalr1.cc:919
+#line 1072 "apr_parser.cc"
           break;
 
-          case 57:
-#line 303 "aprepro.yy" // lalr1.cc:919
+          case 60:
+#line 316 "aprepro.yy"
           {
             concat_string((yystack_[2].value.string), (yystack_[0].value.string),
                           &(yylhs.value.string));
           }
-#line 1048 "apr_parser.cc" // lalr1.cc:919
+#line 1078 "apr_parser.cc"
           break;
 
-          case 58:
-#line 304 "aprepro.yy" // lalr1.cc:919
+          case 61:
+#line 317 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.strfnct_dd == NULL))
@@ -1073,11 +1107,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1059 "apr_parser.cc" // lalr1.cc:919
+#line 1089 "apr_parser.cc"
           break;
 
-          case 59:
-#line 310 "aprepro.yy" // lalr1.cc:919
+          case 62:
+#line 323 "aprepro.yy"
           {
             if (arg_check((yystack_[11].value.tptr),
                           (yystack_[11].value.tptr)->value.strfnct_dcccc == NULL))
@@ -1087,11 +1121,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1070 "apr_parser.cc" // lalr1.cc:919
+#line 1100 "apr_parser.cc"
           break;
 
-          case 60:
-#line 316 "aprepro.yy" // lalr1.cc:919
+          case 63:
+#line 329 "aprepro.yy"
           {
             if (arg_check((yystack_[7].value.tptr),
                           (yystack_[7].value.tptr)->value.strfnct_dcc == NULL))
@@ -1100,11 +1134,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1081 "apr_parser.cc" // lalr1.cc:919
+#line 1111 "apr_parser.cc"
           break;
 
-          case 61:
-#line 322 "aprepro.yy" // lalr1.cc:919
+          case 64:
+#line 335 "aprepro.yy"
           {
             if (arg_check((yystack_[7].value.tptr),
                           (yystack_[7].value.tptr)->value.strfnct_ccc == NULL))
@@ -1114,11 +1148,11 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1092 "apr_parser.cc" // lalr1.cc:919
+#line 1122 "apr_parser.cc"
           break;
 
-          case 62:
-#line 328 "aprepro.yy" // lalr1.cc:919
+          case 65:
+#line 341 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.strfnct_cc == NULL))
@@ -1127,149 +1161,161 @@ namespace SEAMS {
             else
               (yylhs.value.string) = (char *)"";
           }
-#line 1103 "apr_parser.cc" // lalr1.cc:919
+#line 1133 "apr_parser.cc"
           break;
 
-          case 63:
-#line 334 "aprepro.yy" // lalr1.cc:919
+          case 66:
+#line 347 "aprepro.yy"
           {
             (yylhs.value.string) = ((yystack_[4].value.val)) ? ((yystack_[2].value.string))
                                                              : ((yystack_[0].value.string));
           }
-#line 1109 "apr_parser.cc" // lalr1.cc:919
+#line 1139 "apr_parser.cc"
           break;
 
-          case 64:
-#line 336 "aprepro.yy" // lalr1.cc:919
+          case 67:
+#line 349 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.val);
           }
-#line 1115 "apr_parser.cc" // lalr1.cc:919
+#line 1145 "apr_parser.cc"
           break;
 
-          case 65:
-#line 337 "aprepro.yy" // lalr1.cc:919
+          case 68:
+#line 350 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.val) + 1;
           }
-#line 1121 "apr_parser.cc" // lalr1.cc:919
+#line 1151 "apr_parser.cc"
           break;
 
-          case 66:
-#line 338 "aprepro.yy" // lalr1.cc:919
+          case 69:
+#line 351 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.val) - 1;
           }
-#line 1127 "apr_parser.cc" // lalr1.cc:919
+#line 1157 "apr_parser.cc"
           break;
 
-          case 67:
-#line 339 "aprepro.yy" // lalr1.cc:919
+          case 70:
+#line 352 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.tptr)->value.var;
           }
-#line 1133 "apr_parser.cc" // lalr1.cc:919
+#line 1163 "apr_parser.cc"
           break;
 
-          case 68:
-#line 340 "aprepro.yy" // lalr1.cc:919
+          case 71:
+#line 353 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.tptr)->value.var;
           }
-#line 1139 "apr_parser.cc" // lalr1.cc:919
+#line 1169 "apr_parser.cc"
           break;
 
-          case 69:
-#line 341 "aprepro.yy" // lalr1.cc:919
+          case 72:
+#line 354 "aprepro.yy"
           {
             (yylhs.value.val) = ++((yystack_[0].value.tptr)->value.var);
           }
-#line 1145 "apr_parser.cc" // lalr1.cc:919
+#line 1175 "apr_parser.cc"
           break;
 
-          case 70:
-#line 342 "aprepro.yy" // lalr1.cc:919
+          case 73:
+#line 355 "aprepro.yy"
           {
             (yylhs.value.val) = --((yystack_[0].value.tptr)->value.var);
           }
-#line 1151 "apr_parser.cc" // lalr1.cc:919
+#line 1181 "apr_parser.cc"
           break;
 
-          case 71:
-#line 343 "aprepro.yy" // lalr1.cc:919
+          case 74:
+#line 356 "aprepro.yy"
           {
             (yylhs.value.val) = ((yystack_[1].value.tptr)->value.var)++;
           }
-#line 1157 "apr_parser.cc" // lalr1.cc:919
+#line 1187 "apr_parser.cc"
           break;
 
-          case 72:
-#line 344 "aprepro.yy" // lalr1.cc:919
+          case 75:
+#line 357 "aprepro.yy"
           {
             (yylhs.value.val) = ((yystack_[1].value.tptr)->value.var)--;
           }
-#line 1163 "apr_parser.cc" // lalr1.cc:919
+#line 1193 "apr_parser.cc"
           break;
 
-          case 73:
-#line 345 "aprepro.yy" // lalr1.cc:919
+          case 76:
+#line 358 "aprepro.yy"
           {
             (yylhs.value.val)                   = (yystack_[0].value.val);
             (yystack_[2].value.tptr)->value.var = (yystack_[0].value.val);
             redefined_warning(aprepro, (yystack_[2].value.tptr));
           }
-#line 1170 "apr_parser.cc" // lalr1.cc:919
+#line 1200 "apr_parser.cc"
           break;
 
-          case 74:
-#line 347 "aprepro.yy" // lalr1.cc:919
+          case 77:
+#line 360 "aprepro.yy"
           {
             (yylhs.value.val)                   = (yystack_[0].value.val);
             (yystack_[2].value.tptr)->value.var = (yystack_[0].value.val);
             redefined_warning(aprepro, (yystack_[2].value.tptr));
             set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
           }
-#line 1178 "apr_parser.cc" // lalr1.cc:919
+#line 1208 "apr_parser.cc"
           break;
 
-          case 75:
-#line 350 "aprepro.yy" // lalr1.cc:919
+          case 78:
+#line 363 "aprepro.yy"
+          {
+            (yylhs.value.val) = (yystack_[0].value.val);
+            delete (yystack_[2].value.tptr)->value.avar;
+            (yystack_[2].value.tptr)->value.var = (yystack_[0].value.val);
+            redefined_warning(aprepro, (yystack_[2].value.tptr));
+            set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
+          }
+#line 1218 "apr_parser.cc"
+          break;
+
+          case 79:
+#line 368 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var += (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
           }
-#line 1184 "apr_parser.cc" // lalr1.cc:919
+#line 1224 "apr_parser.cc"
           break;
 
-          case 76:
-#line 351 "aprepro.yy" // lalr1.cc:919
+          case 80:
+#line 369 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var -= (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
           }
-#line 1190 "apr_parser.cc" // lalr1.cc:919
+#line 1230 "apr_parser.cc"
           break;
 
-          case 77:
-#line 352 "aprepro.yy" // lalr1.cc:919
+          case 81:
+#line 370 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var *= (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
           }
-#line 1196 "apr_parser.cc" // lalr1.cc:919
+#line 1236 "apr_parser.cc"
           break;
 
-          case 78:
-#line 353 "aprepro.yy" // lalr1.cc:919
+          case 82:
+#line 371 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var /= (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
           }
-#line 1202 "apr_parser.cc" // lalr1.cc:919
+#line 1242 "apr_parser.cc"
           break;
 
-          case 79:
-#line 354 "aprepro.yy" // lalr1.cc:919
+          case 83:
+#line 372 "aprepro.yy"
           {
             reset_error();
             (yystack_[2].value.tptr)->value.var =
@@ -1277,213 +1323,213 @@ namespace SEAMS {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             SEAMS::math_error(aprepro, "Power");
           }
-#line 1212 "apr_parser.cc" // lalr1.cc:919
+#line 1252 "apr_parser.cc"
           break;
 
-          case 80:
-#line 359 "aprepro.yy" // lalr1.cc:919
+          case 84:
+#line 377 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[0].value.tptr));
           }
-#line 1218 "apr_parser.cc" // lalr1.cc:919
+#line 1258 "apr_parser.cc"
           break;
 
-          case 81:
-#line 360 "aprepro.yy" // lalr1.cc:919
+          case 85:
+#line 378 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[0].value.tptr));
           }
-#line 1224 "apr_parser.cc" // lalr1.cc:919
+#line 1264 "apr_parser.cc"
           break;
 
-          case 82:
-#line 361 "aprepro.yy" // lalr1.cc:919
+          case 86:
+#line 379 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[1].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[1].value.tptr));
           }
-#line 1230 "apr_parser.cc" // lalr1.cc:919
+#line 1270 "apr_parser.cc"
           break;
 
-          case 83:
-#line 362 "aprepro.yy" // lalr1.cc:919
+          case 87:
+#line 380 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[1].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[1].value.tptr));
           }
-#line 1236 "apr_parser.cc" // lalr1.cc:919
+#line 1276 "apr_parser.cc"
           break;
 
-          case 84:
-#line 363 "aprepro.yy" // lalr1.cc:919
+          case 88:
+#line 381 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 1242 "apr_parser.cc" // lalr1.cc:919
+#line 1282 "apr_parser.cc"
           break;
 
-          case 85:
-#line 364 "aprepro.yy" // lalr1.cc:919
+          case 89:
+#line 382 "aprepro.yy"
           {
             immutable_modify(aprepro, (yystack_[2].value.tptr));
             YYERROR;
           }
-#line 1248 "apr_parser.cc" // lalr1.cc:919
+#line 1288 "apr_parser.cc"
           break;
 
-          case 86:
-#line 365 "aprepro.yy" // lalr1.cc:919
+          case 90:
+#line 383 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 1254 "apr_parser.cc" // lalr1.cc:919
+#line 1294 "apr_parser.cc"
           break;
 
-          case 87:
-#line 366 "aprepro.yy" // lalr1.cc:919
+          case 91:
+#line 384 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 1260 "apr_parser.cc" // lalr1.cc:919
+#line 1300 "apr_parser.cc"
           break;
 
-          case 88:
-#line 367 "aprepro.yy" // lalr1.cc:919
+          case 92:
+#line 385 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 1266 "apr_parser.cc" // lalr1.cc:919
+#line 1306 "apr_parser.cc"
           break;
 
-          case 89:
-#line 368 "aprepro.yy" // lalr1.cc:919
+          case 93:
+#line 386 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 1272 "apr_parser.cc" // lalr1.cc:919
+#line 1312 "apr_parser.cc"
           break;
 
-          case 90:
-#line 369 "aprepro.yy" // lalr1.cc:919
+          case 94:
+#line 387 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             immutable_modify(aprepro, (yystack_[2].value.tptr));
           }
-#line 1278 "apr_parser.cc" // lalr1.cc:919
+#line 1318 "apr_parser.cc"
           break;
 
-          case 91:
-#line 371 "aprepro.yy" // lalr1.cc:919
+          case 95:
+#line 389 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.tptr)->value.var;
             undefined_error(aprepro, (yystack_[0].value.tptr)->name);
           }
-#line 1285 "apr_parser.cc" // lalr1.cc:919
+#line 1325 "apr_parser.cc"
           break;
 
-          case 92:
-#line 373 "aprepro.yy" // lalr1.cc:919
+          case 96:
+#line 391 "aprepro.yy"
           {
             (yylhs.value.val) = ++((yystack_[0].value.tptr)->value.var);
             set_type(aprepro, (yystack_[0].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[0].value.tptr)->name);
           }
-#line 1293 "apr_parser.cc" // lalr1.cc:919
+#line 1333 "apr_parser.cc"
           break;
 
-          case 93:
-#line 376 "aprepro.yy" // lalr1.cc:919
+          case 97:
+#line 394 "aprepro.yy"
           {
             (yylhs.value.val) = --((yystack_[0].value.tptr)->value.var);
             set_type(aprepro, (yystack_[0].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[0].value.tptr)->name);
           }
-#line 1301 "apr_parser.cc" // lalr1.cc:919
+#line 1341 "apr_parser.cc"
           break;
 
-          case 94:
-#line 379 "aprepro.yy" // lalr1.cc:919
+          case 98:
+#line 397 "aprepro.yy"
           {
             (yylhs.value.val) = ((yystack_[1].value.tptr)->value.var)++;
             set_type(aprepro, (yystack_[1].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[1].value.tptr)->name);
           }
-#line 1309 "apr_parser.cc" // lalr1.cc:919
+#line 1349 "apr_parser.cc"
           break;
 
-          case 95:
-#line 382 "aprepro.yy" // lalr1.cc:919
+          case 99:
+#line 400 "aprepro.yy"
           {
             (yylhs.value.val) = ((yystack_[1].value.tptr)->value.var)--;
             set_type(aprepro, (yystack_[1].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[1].value.tptr)->name);
           }
-#line 1317 "apr_parser.cc" // lalr1.cc:919
+#line 1357 "apr_parser.cc"
           break;
 
-          case 96:
-#line 385 "aprepro.yy" // lalr1.cc:919
+          case 100:
+#line 403 "aprepro.yy"
           {
             (yylhs.value.val)                   = (yystack_[0].value.val);
             (yystack_[2].value.tptr)->value.var = (yystack_[0].value.val);
             set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
           }
-#line 1324 "apr_parser.cc" // lalr1.cc:919
+#line 1364 "apr_parser.cc"
           break;
 
-          case 97:
-#line 387 "aprepro.yy" // lalr1.cc:919
+          case 101:
+#line 405 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var += (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[2].value.tptr)->name);
           }
-#line 1332 "apr_parser.cc" // lalr1.cc:919
+#line 1372 "apr_parser.cc"
           break;
 
-          case 98:
-#line 390 "aprepro.yy" // lalr1.cc:919
+          case 102:
+#line 408 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var -= (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[2].value.tptr)->name);
           }
-#line 1340 "apr_parser.cc" // lalr1.cc:919
+#line 1380 "apr_parser.cc"
           break;
 
-          case 99:
-#line 393 "aprepro.yy" // lalr1.cc:919
+          case 103:
+#line 411 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var *= (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[2].value.tptr)->name);
           }
-#line 1348 "apr_parser.cc" // lalr1.cc:919
+#line 1388 "apr_parser.cc"
           break;
 
-          case 100:
-#line 396 "aprepro.yy" // lalr1.cc:919
+          case 104:
+#line 414 "aprepro.yy"
           {
             (yystack_[2].value.tptr)->value.var /= (yystack_[0].value.val);
             (yylhs.value.val) = (yystack_[2].value.tptr)->value.var;
             set_type(aprepro, (yystack_[2].value.tptr), token::VAR);
             undefined_error(aprepro, (yystack_[2].value.tptr)->name);
           }
-#line 1356 "apr_parser.cc" // lalr1.cc:919
+#line 1396 "apr_parser.cc"
           break;
 
-          case 101:
-#line 399 "aprepro.yy" // lalr1.cc:919
+          case 105:
+#line 417 "aprepro.yy"
           {
             reset_error();
             (yystack_[2].value.tptr)->value.var =
@@ -1493,11 +1539,11 @@ namespace SEAMS {
             SEAMS::math_error(aprepro, "Power");
             undefined_error(aprepro, (yystack_[2].value.tptr)->name);
           }
-#line 1367 "apr_parser.cc" // lalr1.cc:919
+#line 1407 "apr_parser.cc"
           break;
 
-          case 102:
-#line 406 "aprepro.yy" // lalr1.cc:919
+          case 106:
+#line 424 "aprepro.yy"
           {
             if (arg_check((yystack_[2].value.tptr),
                           (yystack_[2].value.tptr)->value.fnctptr == NULL))
@@ -1505,11 +1551,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1378 "apr_parser.cc" // lalr1.cc:919
+#line 1418 "apr_parser.cc"
           break;
 
-          case 103:
-#line 413 "aprepro.yy" // lalr1.cc:919
+          case 107:
+#line 431 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.fnctptr_d == NULL))
@@ -1518,11 +1564,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1389 "apr_parser.cc" // lalr1.cc:919
+#line 1429 "apr_parser.cc"
           break;
 
-          case 104:
-#line 420 "aprepro.yy" // lalr1.cc:919
+          case 108:
+#line 438 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.fnctptr_c == NULL))
@@ -1531,11 +1577,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1400 "apr_parser.cc" // lalr1.cc:919
+#line 1440 "apr_parser.cc"
           break;
 
-          case 105:
-#line 427 "aprepro.yy" // lalr1.cc:919
+          case 109:
+#line 445 "aprepro.yy"
           {
             if (arg_check((yystack_[3].value.tptr),
                           (yystack_[3].value.tptr)->value.fnctptr_a == NULL))
@@ -1544,11 +1590,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1411 "apr_parser.cc" // lalr1.cc:919
+#line 1451 "apr_parser.cc"
           break;
 
-          case 106:
-#line 434 "aprepro.yy" // lalr1.cc:919
+          case 110:
+#line 452 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.fnctptr_cd == NULL))
@@ -1557,11 +1603,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1422 "apr_parser.cc" // lalr1.cc:919
+#line 1462 "apr_parser.cc"
           break;
 
-          case 107:
-#line 441 "aprepro.yy" // lalr1.cc:919
+          case 111:
+#line 459 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.fnctptr_dc == NULL))
@@ -1570,11 +1616,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1433 "apr_parser.cc" // lalr1.cc:919
+#line 1473 "apr_parser.cc"
           break;
 
-          case 108:
-#line 448 "aprepro.yy" // lalr1.cc:919
+          case 112:
+#line 466 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.fnctptr_cc == NULL))
@@ -1583,11 +1629,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1444 "apr_parser.cc" // lalr1.cc:919
+#line 1484 "apr_parser.cc"
           break;
 
-          case 109:
-#line 455 "aprepro.yy" // lalr1.cc:919
+          case 113:
+#line 473 "aprepro.yy"
           {
             if (arg_check((yystack_[7].value.tptr),
                           (yystack_[7].value.tptr)->value.fnctptr_ccc == NULL))
@@ -1597,11 +1643,11 @@ namespace SEAMS {
             else
               yyerrok;
           }
-#line 1455 "apr_parser.cc" // lalr1.cc:919
+#line 1495 "apr_parser.cc"
           break;
 
-          case 110:
-#line 462 "aprepro.yy" // lalr1.cc:919
+          case 114:
+#line 480 "aprepro.yy"
           {
             if (arg_check((yystack_[5].value.tptr),
                           (yystack_[5].value.tptr)->value.fnctptr_dd == NULL))
@@ -1610,11 +1656,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1466 "apr_parser.cc" // lalr1.cc:919
+#line 1506 "apr_parser.cc"
           break;
 
-          case 111:
-#line 468 "aprepro.yy" // lalr1.cc:919
+          case 115:
+#line 486 "aprepro.yy"
           {
             if (arg_check((yystack_[7].value.tptr),
                           (yystack_[7].value.tptr)->value.fnctptr_ddd == NULL))
@@ -1623,11 +1669,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1477 "apr_parser.cc" // lalr1.cc:919
+#line 1517 "apr_parser.cc"
           break;
 
-          case 112:
-#line 474 "aprepro.yy" // lalr1.cc:919
+          case 116:
+#line 492 "aprepro.yy"
           {
             if (arg_check((yystack_[7].value.tptr),
                           (yystack_[7].value.tptr)->value.fnctptr_ccd == NULL))
@@ -1636,11 +1682,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1488 "apr_parser.cc" // lalr1.cc:919
+#line 1528 "apr_parser.cc"
           break;
 
-          case 113:
-#line 480 "aprepro.yy" // lalr1.cc:919
+          case 117:
+#line 498 "aprepro.yy"
           {
             if (arg_check((yystack_[9].value.tptr),
                           (yystack_[9].value.tptr)->value.fnctptr_dddd == NULL))
@@ -1650,11 +1696,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1499 "apr_parser.cc" // lalr1.cc:919
+#line 1539 "apr_parser.cc"
           break;
 
-          case 114:
-#line 486 "aprepro.yy" // lalr1.cc:919
+          case 118:
+#line 504 "aprepro.yy"
           {
             if (arg_check((yystack_[9].value.tptr),
                           (yystack_[9].value.tptr)->value.fnctptr_dddd == NULL))
@@ -1664,11 +1710,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1510 "apr_parser.cc" // lalr1.cc:919
+#line 1550 "apr_parser.cc"
           break;
 
-          case 115:
-#line 492 "aprepro.yy" // lalr1.cc:919
+          case 119:
+#line 510 "aprepro.yy"
           {
             if (arg_check((yystack_[11].value.tptr),
                           (yystack_[11].value.tptr)->value.fnctptr_ddddc == NULL))
@@ -1678,11 +1724,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1521 "apr_parser.cc" // lalr1.cc:919
+#line 1561 "apr_parser.cc"
           break;
 
-          case 116:
-#line 498 "aprepro.yy" // lalr1.cc:919
+          case 120:
+#line 516 "aprepro.yy"
           {
             if (arg_check((yystack_[13].value.tptr),
                           (yystack_[13].value.tptr)->value.fnctptr_dddddd == NULL))
@@ -1692,35 +1738,35 @@ namespace SEAMS {
             else
               (yylhs.value.val) = 0.0;
           }
-#line 1532 "apr_parser.cc" // lalr1.cc:919
+#line 1572 "apr_parser.cc"
           break;
 
-          case 117:
-#line 504 "aprepro.yy" // lalr1.cc:919
+          case 121:
+#line 522 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) + (yystack_[0].value.val);
           }
-#line 1538 "apr_parser.cc" // lalr1.cc:919
+#line 1578 "apr_parser.cc"
           break;
 
-          case 118:
-#line 505 "aprepro.yy" // lalr1.cc:919
+          case 122:
+#line 523 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) - (yystack_[0].value.val);
           }
-#line 1544 "apr_parser.cc" // lalr1.cc:919
+#line 1584 "apr_parser.cc"
           break;
 
-          case 119:
-#line 506 "aprepro.yy" // lalr1.cc:919
+          case 123:
+#line 524 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[2].value.val) * (yystack_[0].value.val);
           }
-#line 1550 "apr_parser.cc" // lalr1.cc:919
+#line 1590 "apr_parser.cc"
           break;
 
-          case 120:
-#line 507 "aprepro.yy" // lalr1.cc:919
+          case 124:
+#line 525 "aprepro.yy"
           {
             if ((yystack_[0].value.val) == 0.) {
               yyerror(aprepro, "Zero divisor");
@@ -1729,11 +1775,11 @@ namespace SEAMS {
             else
               (yylhs.value.val) = (yystack_[2].value.val) / (yystack_[0].value.val);
           }
-#line 1562 "apr_parser.cc" // lalr1.cc:919
+#line 1602 "apr_parser.cc"
           break;
 
-          case 121:
-#line 514 "aprepro.yy" // lalr1.cc:919
+          case 125:
+#line 532 "aprepro.yy"
           {
             if ((yystack_[0].value.val) == 0.) {
               yyerror(aprepro, "Zero divisor");
@@ -1742,45 +1788,45 @@ namespace SEAMS {
             else
               (yylhs.value.val) = (int)(yystack_[2].value.val) % (int)(yystack_[0].value.val);
           }
-#line 1574 "apr_parser.cc" // lalr1.cc:919
+#line 1614 "apr_parser.cc"
           break;
 
-          case 122:
-#line 521 "aprepro.yy" // lalr1.cc:919
+          case 126:
+#line 539 "aprepro.yy"
           {
             (yylhs.value.val) = -(yystack_[0].value.val);
           }
-#line 1580 "apr_parser.cc" // lalr1.cc:919
+#line 1620 "apr_parser.cc"
           break;
 
-          case 123:
-#line 522 "aprepro.yy" // lalr1.cc:919
+          case 127:
+#line 540 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.val);
           }
-#line 1586 "apr_parser.cc" // lalr1.cc:919
+#line 1626 "apr_parser.cc"
           break;
 
-          case 124:
-#line 523 "aprepro.yy" // lalr1.cc:919
+          case 128:
+#line 541 "aprepro.yy"
           {
             reset_error();
             (yylhs.value.val) = std::pow((yystack_[2].value.val), (yystack_[0].value.val));
             SEAMS::math_error(aprepro, "Power");
           }
-#line 1594 "apr_parser.cc" // lalr1.cc:919
+#line 1634 "apr_parser.cc"
           break;
 
-          case 125:
-#line 526 "aprepro.yy" // lalr1.cc:919
+          case 129:
+#line 544 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[1].value.val);
           }
-#line 1600 "apr_parser.cc" // lalr1.cc:919
+#line 1640 "apr_parser.cc"
           break;
 
-          case 126:
-#line 527 "aprepro.yy" // lalr1.cc:919
+          case 130:
+#line 545 "aprepro.yy"
           {
             reset_error();
             (yylhs.value.val) =
@@ -1788,46 +1834,46 @@ namespace SEAMS {
                                                      : floor((yystack_[1].value.val)));
             SEAMS::math_error(aprepro, "floor (int)");
           }
-#line 1608 "apr_parser.cc" // lalr1.cc:919
+#line 1648 "apr_parser.cc"
           break;
 
-          case 127:
-#line 530 "aprepro.yy" // lalr1.cc:919
+          case 131:
+#line 548 "aprepro.yy"
           {
             (yylhs.value.val) = ((yystack_[0].value.val)) ? 1 : 0;
           }
-#line 1614 "apr_parser.cc" // lalr1.cc:919
+#line 1654 "apr_parser.cc"
           break;
 
-          case 128:
-#line 531 "aprepro.yy" // lalr1.cc:919
+          case 132:
+#line 549 "aprepro.yy"
           {
             (yylhs.value.val) =
                 ((yystack_[4].value.val)) ? ((yystack_[2].value.val)) : ((yystack_[0].value.val));
           }
-#line 1620 "apr_parser.cc" // lalr1.cc:919
+#line 1660 "apr_parser.cc"
           break;
 
-          case 129:
-#line 532 "aprepro.yy" // lalr1.cc:919
+          case 133:
+#line 550 "aprepro.yy"
           {
             (yylhs.value.val) =
                 array_value((yystack_[3].value.tptr)->value.avar, (yystack_[1].value.val), 0);
           }
-#line 1626 "apr_parser.cc" // lalr1.cc:919
+#line 1666 "apr_parser.cc"
           break;
 
-          case 130:
-#line 533 "aprepro.yy" // lalr1.cc:919
+          case 134:
+#line 551 "aprepro.yy"
           {
             (yylhs.value.val) = array_value((yystack_[5].value.tptr)->value.avar,
                                             (yystack_[3].value.val), (yystack_[1].value.val));
           }
-#line 1632 "apr_parser.cc" // lalr1.cc:919
+#line 1672 "apr_parser.cc"
           break;
 
-          case 131:
-#line 535 "aprepro.yy" // lalr1.cc:919
+          case 135:
+#line 553 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.val);
             array *arr        = (yystack_[5].value.tptr)->value.avar;
@@ -1850,11 +1896,11 @@ namespace SEAMS {
               yyerrok;
             }
           }
-#line 1658 "apr_parser.cc" // lalr1.cc:919
+#line 1698 "apr_parser.cc"
           break;
 
-          case 132:
-#line 557 "aprepro.yy" // lalr1.cc:919
+          case 136:
+#line 575 "aprepro.yy"
           {
             (yylhs.value.val) = (yystack_[0].value.val);
             array *arr        = (yystack_[7].value.tptr)->value.avar;
@@ -1875,10 +1921,11 @@ namespace SEAMS {
               yyerrok;
             }
           }
-#line 1682 "apr_parser.cc" // lalr1.cc:919
+#line 1722 "apr_parser.cc"
           break;
 
-#line 1686 "apr_parser.cc" // lalr1.cc:919
+#line 1726 "apr_parser.cc"
+
           default: break;
           }
         }
@@ -2116,216 +2163,219 @@ namespace SEAMS {
   const signed char Parser::yytable_ninf_ = -1;
 
   const short Parser::yypact_[] = {
-      -34,  2,    -34,  -3,   289,  -34,  -34,  -34,  -34,  -34,  -13,  296,  4,    600,  28,
-      45,   44,   46,   53,   405,  405,  -34,  405,  360,  405,  111,  179,  48,   -16,  38,
-      1126, 360,  405,  405,  405,  405,  405,  -34,  -34,  405,  405,  405,  405,  405,  405,
-      -34,  -34,  405,  405,  405,  405,  405,  405,  405,  -34,  -34,  405,  405,  360,  209,
-      345,  360,  630,  52,   405,  93,   1174, 864,  1078, 18,   -34,  18,   18,   -34,  -34,
-      -34,  -34,  -34,  -34,  -34,  -34,  405,  405,  405,  -34,  360,  360,  405,  360,  -34,
-      405,  405,  405,  405,  405,  405,  405,  -34,  405,  405,  405,  405,  405,  405,  405,
-      405,  405,  405,  405,  360,  405,  405,  -33,  1174, 1193, 1209, 1209, 1209, 1209, 1209,
-      1174, 1209, 1209, 1209, 1209, 1209, 1209, 1174, 1209, 1174, 1209, 1209, 1209, 1209, 1209,
-      1209, 1174, 1209, 599,  -33,  1193, -34,  50,   99,   629,  -34,  154,  229,  659,  230,
-      421,  689,  405,  18,   -34,  -34,  405,  -34,  1140, 1160, 49,   1209, -34,  1,    1,
-      1225, -34,  1225, 39,   39,   39,   39,   39,   39,   -34,  1240, 1254, 340,  340,  340,
-      340,  340,  340,  190,  190,  18,   -34,  18,   18,   18,   405,  70,   -34,  405,  -34,
-      405,  -34,  -34,  405,  -34,  405,  -34,  -34,  405,  -34,  405,  -34,  1209, 18,   405,
-      405,  1103, 405,  431,  891,  484,  570,  456,  131,  918,  490,  945,  719,  1174, 1209,
-      71,   1209, 405,  -34,  -34,  -34,  405,  -34,  405,  405,  -34,  405,  -34,  -34,  -34,
-      405,  -34,  405,  512,  972,  749,  808,  518,  462,  999,  1209, -34,  -34,  405,  -34,
-      405,  -34,  405,  -34,  -34,  779,  1026, 391,  405,  -34,  -34,  405,  540,  837,  546,
-      -34,  405,  -34,  1053, -34};
+      -34,  2,    -34, -3,   305,  -34,  -34,  -34,  -34,  -34,  -13,  68,   4,    312,  28,   47,
+      53,   62,   67,  421,  421,  -34,  421,  376,  421,  55,   181,  50,   -16,  39,   1142, 376,
+      421,  421,  421, 421,  421,  -34,  -34,  376,  421,  421,  421,  421,  421,  -34,  -34,  376,
+      421,  421,  421, 421,  421,  421,  -34,  -34,  421,  421,  376,  221,  361,  376,  616,  646,
+      95,   48,   421, 107,  1190, 880,  1094, 82,   -34,  82,   82,   -34,  -34,  -34,  -34,  -34,
+      -34,  -34,  -34, 421,  421,  421,  -34,  376,  376,  421,  376,  -34,  421,  421,  421,  421,
+      421,  421,  421, -34,  421,  421,  421,  421,  421,  421,  421,  421,  421,  421,  421,  376,
+      421,  421,  -33, 1190, 1209, 1225, 1225, 1225, 1225, 1225, -33,  1190, 1209, 1225, 1225, 1225,
+      1225, 1225, -33, 1190, 1209, 1190, 1225, 1225, 1225, 1225, 1225, 1225, 1190, 1225, 615,  -33,
+      1190, 1209, -34, 72,   240,  645,  -34,  262,  248,  675,  288,  437,  705,  421,  421,  421,
+      421,  82,   -34, -34,  421,  -34,  1156, 1176, 97,   1225, -34,  1,    1209, 1,    1241, -34,
+      1241, 81,   81,  81,   81,   81,   81,   -34,  1256, 1270, 80,   80,   80,   80,   80,   80,
+      161,  161,  82,  -34,  82,   82,   82,   421,  108,  -34,  421,  -34,  421,  -34,  -34,  421,
+      -34,  421,  -34, -34,  421,  -34,  421,  -34,  1225, 1225, 1225, 1225, 82,   421,  421,  1119,
+      421,  447,  907, 500,  586,  472,  137,  934,  506,  961,  735,  1190, 1225, 109,  1225, 421,
+      -34,  -34,  -34, 421,  -34,  421,  421,  -34,  421,  -34,  -34,  -34,  421,  -34,  421,  528,
+      988,  765,  824, 534,  478,  1015, 1225, -34,  -34,  421,  -34,  421,  -34,  421,  -34,  -34,
+      795,  1042, 407, 421,  -34,  -34,  421,  556,  853,  562,  -34,  421,  -34,  1069, -34};
 
   const unsigned char Parser::yydefact_[] = {
-      2,   0,   1,   0,   0,   4,   3,   9,   64,  45, 91, 67, 46,  68,  47,  28,  0,   0,   0,
-      0,   0,   8,   0,   0,   0,   0,   0,   127, 0,  0,  0,  0,   0,   0,   0,   0,   0,   94,
-      95,  0,   0,   0,   0,   0,   0,   71,  72,  0,  0,  0,  0,   0,   0,   0,   82,  83,  0,
-      0,   0,   0,   0,   0,   91,  0,   0,   127, 0,  0,  0,  123, 39,  122, 12,  65,  92,  69,
-      80,  66,  93,  70,  81,  0,   0,   0,   7,   0,  0,  0,  0,   6,   0,   0,   0,   0,   0,
-      0,   0,   5,   0,   0,   0,   0,   0,   0,   0,  0,  0,  0,   0,   0,   0,   0,   37,  48,
-      96,  97,  98,  99,  100, 101, 50,  73,  75,  76, 77, 78, 79,  49,  74,  52,  84,  86,  87,
-      88,  89,  90,  51,  85,  0,   36,  0,   102, 0,  0,  0,  54,  0,   0,   0,   0,   0,   0,
-      0,   122, 21,  125, 0,   126, 0,   0,   19,  0,  20, 38, 40,  42,  44,  41,  22,  23,  24,
-      25,  26,  27,  57,  17,  18,  10,  11,  13,  14, 15, 16, 117, 118, 120, 43,  119, 121, 124,
-      0,   129, 105, 0,   104, 0,   103, 56,  0,   53, 0,  55, 35,  0,   29,  0,   34,  96,  119,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  0,  0,  0,   0,   63,  128, 130, 131, 0,
-      108, 106, 107, 0,   110, 0,   0,   62,  0,   58, 31, 30, 0,   33,  0,   0,   0,   0,   0,
-      0,   0,   0,   132, 109, 112, 0,   111, 0,   61, 0,  60, 32,  0,   0,   0,   0,   114, 113,
-      0,   0,   0,   0,   115, 0,   59,  0,   116};
-
-  const signed char Parser::yypgoto_[] = {-34, -34, -34, -18, 95, 81, -4};
-
-  const short Parser::yydefgoto_[] = {-1, 1, 6, 27, 28, 66, 161};
+      2,   0,   1,   0,   0,   4,   3,   9,   67,  47,  95,  70,  48,  71,  49,  28, 0,   0,
+      0,   0,   0,   8,   0,   0,   0,   0,   0,   131, 0,   0,   0,   0,   0,   0,  0,   0,
+      0,   98,  99,  0,   0,   0,   0,   0,   0,   74,  75,  0,   0,   0,   0,   0,  0,   0,
+      86,  87,  0,   0,   0,   0,   0,   0,   95,  70,  48,  0,   0,   131, 0,   0,  0,   127,
+      41,  126, 12,  68,  96,  72,  84,  69,  97,  73,  85,  0,   0,   0,   7,   0,  0,   0,
+      0,   6,   0,   0,   0,   0,   0,   0,   0,   5,   0,   0,   0,   0,   0,   0,  0,   0,
+      0,   0,   0,   0,   0,   0,   39,  50,  100, 101, 102, 103, 104, 105, 37,  52, 76,  79,
+      80,  81,  82,  83,  36,  51,  77,  55,  88,  90,  91,  92,  93,  94,  54,  89, 0,   38,
+      53,  78,  106, 0,   0,   0,   57,  0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   126,
+      21,  129, 0,   130, 0,   0,   19,  0,   20,  40,  0,   42,  44,  46,  43,  22, 23,  24,
+      25,  26,  27,  60,  17,  18,  10,  11,  13,  14,  15,  16,  121, 122, 124, 45, 123, 125,
+      128, 0,   133, 109, 0,   108, 0,   107, 59,  0,   56,  0,   58,  35,  0,   29, 0,   34,
+      100, 76,  77,  78,  123, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   0,
+      0,   66,  132, 134, 135, 0,   112, 110, 111, 0,   114, 0,   0,   65,  0,   61, 31,  30,
+      0,   33,  0,   0,   0,   0,   0,   0,   0,   0,   136, 113, 116, 0,   115, 0,  64,  0,
+      63,  32,  0,   0,   0,   0,   118, 117, 0,   0,   0,   0,   119, 0,   62,  0,  120};
+
+  const signed char Parser::yypgoto_[] = {-34, -34, -34, -18, 103, 85, -4};
+
+  const short Parser::yydefgoto_[] = {-1, 1, 6, 27, 28, 68, 169};
 
   const unsigned short Parser::yytable_[] = {
-      30,  65,  2,   3,   84,  85,  86,  87,  88,  31,  32,  33,  34,  35,  36,  67,  68,  7,   69,
-      71,  72,  4,   85,  86,  87,  88,  47,  114, 115, 116, 117, 118, 119, 37,  38,  121, 122, 123,
-      124, 125, 126, 87,  88,  128, 130, 131, 132, 133, 134, 135, 56,  5,   137, 138, 140, 144, 148,
-      151, 89,  59,  153, 60,  57,  111, 160, 162, 192, 58,  61,  57,  90,  91,  92,  93,  94,  95,
-      81,  159, 82,  83,  83,  140, 140, 165, 167, 29,  96,  96,  85,  86,  87,  88,  212, 242, 175,
-      176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 187, 188, 189, 0,   154, 0,   0,   113, 193,
-      73,  194, 74,  75,  70,  76,  120, 81,  0,   82,  83,  0,   112, 0,   127, 129, 0,   90,  91,
-      92,  93,  94,  95,  136, 0,   0,   143, 147, 150, 0,   0,   236, 0,   96,  207, 0,   0,   0,
-      208, 139, 142, 146, 149, 0,   0,   0,   0,   0,   158, 90,  91,  92,  93,  94,  95,  0,   197,
-      168, 169, 170, 171, 172, 173, 174, 0,   96,  163, 164, 77,  166, 78,  79,  211, 80,  0,   214,
-      0,   216, 85,  86,  87,  88,  219, 0,   0,   221, 0,   222, 0,   0,   186, 0,   224, 0,   226,
-      0,   0,   0,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  244, 19,  141, 20,  245,
-      0,   246, 108, 156, 110, 113, 0,   111, 249, 0,   250, 0,   0,   0,   0,   198, 0,   199, 202,
-      22,  23,  260, 0,   261, 0,   24,  0,   25,  26,  0,   0,   268, 0,   90,  91,  92,  93,  94,
-      95,  273, 85,  86,  87,  88,  0,   0,   213, 0,   215, 96,  0,   217, 0,   218, 0,   0,   220,
-      0,   0,   0,   0,   0,   223, 0,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  0,
-      19,  0,   20,  0,   243, 21,  0,   0,   0,   0,   0,   247, 0,   248, 39,  40,  41,  42,  43,
-      44,  0,   0,   0,   22,  23,  0,   0,   0,   0,   24,  0,   25,  26,  0,   262, 0,   0,   0,
-      45,  46,  267, 0,   0,   269, 8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  0,   19,
-      145, 20,  8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  0,   19,  0,   20,  106, 107,
-      108, 156, 110, 22,  23,  111, 0,   0,   0,   24,  0,   25,  26,  0,   0,   0,   0,   0,   22,
-      23,  0,   0,   0,   0,   24,  266, 25,  26,  8,   9,   62,  11,  12,  13,  14,  63,  16,  17,
-      0,   0,   19,  0,   20,  90,  91,  92,  93,  94,  95,  0,   0,   0,   0,   0,   0,   203, 0,
-      204, 0,   96,  0,   0,   0,   22,  64,  227, 0,   228, 0,   24,  0,   25,  26,  90,  91,  92,
-      93,  94,  95,  0,   0,   0,   0,   90,  91,  92,  93,  94,  95,  96,  234, 0,   235, 0,   0,
-      0,   257, 0,   258, 96,  0,   0,   0,   0,   0,   0,   0,   0,   90,  91,  92,  93,  94,  95,
-      90,  91,  92,  93,  94,  95,  230, 0,   0,   0,   96,  0,   238, 0,   0,   0,   96,  0,   0,
-      0,   0,   0,   90,  91,  92,  93,  94,  95,  90,  91,  92,  93,  94,  95,  251, 0,   0,   0,
-      96,  0,   256, 0,   0,   0,   96,  0,   0,   0,   0,   0,   90,  91,  92,  93,  94,  95,  90,
-      91,  92,  93,  94,  95,  270, 0,   0,   0,   96,  0,   272, 0,   0,   0,   96,  0,   0,   0,
-      0,   0,   90,  91,  92,  93,  94,  95,  90,  91,  92,  93,  94,  95,  231, 0,   232, 0,   96,
-      0,   0,   233, 0,   0,   96,  0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105,
-      106, 107, 108, 156, 110, 190, 0,   111, 0,   191, 0,   0,   0,   0,   48,  49,  50,  51,  52,
-      53,  0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 0,   195, 111, 196,
-      54,  55,  0,   0,   0,   0,   152, 32,  33,  34,  35,  36,  0,   98,  99,  100, 101, 102, 103,
-      104, 105, 106, 107, 108, 109, 110, 0,   200, 111, 201, 37,  38,  0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 0,
-      205, 111, 206, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100,
-      101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 0,   240, 111, 241, 0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108,
-      156, 110, 0,   253, 111, 254, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 0,   263, 111, 264, 0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105,
-      106, 107, 108, 156, 110, 255, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 271, 0,   111, 0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104,
-      105, 106, 107, 108, 156, 110, 155, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 229, 0,   111, 0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107,
-      108, 156, 110, 237, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,
-      100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 239, 0,   111, 0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110,
-      252, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102,
-      103, 104, 105, 106, 107, 108, 156, 110, 259, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 265, 0,   111,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105,
-      106, 107, 108, 156, 110, 274, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 157, 0,   111, 0,   0,   0,
-      0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110,
-      225, 0,   111, 0,   0,   0,   0,   0,   0,   0,   0,   0,   98,  99,  100, 101, 102, 103, 104,
-      105, 106, 107, 108, 156, 110, 97,  0,   111, 0,   0,   0,   0,   0,   0,   0,   98,  99,  100,
-      101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 209, 0,   111, 90,  91,  92,  93,  94,  95,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   96,  210, 98,  99,  100, 101, 102, 103, 104,
-      105, 106, 107, 108, 156, 110, 0,   0,   111, 90,  91,  92,  93,  94,  95,  0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   96,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
-      110, 0,   0,   111, 98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 0,   0,
-      111, 98,  99,  100, 101, 102, 103, 104, 105, 0,   0,   0,   0,   110, 0,   0,   111, 99,  100,
-      101, 102, 103, 104, 105, 106, 107, 108, 156, 110, 0,   0,   111, 100, 101, 102, 103, 104, 105,
-      106, 107, 108, 156, 110, 0,   0,   111};
+      30,  67,  2,   3,   86,  87,  88,  89,  90,  31,  32,  33,  34,  35,  36,  69,  70,  7,   71,
+      73,  74,  4,   87,  88,  89,  90,  47,  116, 117, 118, 119, 120, 121, 37,  38,  124, 125, 126,
+      127, 128, 129, 89,  90,  132, 134, 135, 136, 137, 138, 139, 56,  5,   141, 142, 145, 149, 153,
+      156, 75,  91,  76,  77,  161, 78,  57,  57,  168, 170, 59,  58,  160, 92,  93,  94,  95,  96,
+      97,  60,  83,  167, 84,  85,  61,  172, 172, 174, 176, 98,  201, 29,  39,  40,  41,  42,  43,
+      44,  184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 196, 197, 198, 87,  88,  89,  90,
+      45,  46,  115, 159, 108, 109, 110, 164, 112, 162, 123, 113, 72,  113, 85,  98,  224, 254, 131,
+      133, 114, 83,  0,   84,  85,  0,   0,   140, 122, 144, 148, 152, 155, 0,   0,   0,   130, 248,
+      0,   216, 217, 218, 219, 0,   0,   0,   220, 143, 147, 151, 154, 0,   0,   0,   166, 92,  93,
+      94,  95,  96,  97,  0,   0,   177, 178, 179, 180, 181, 182, 183, 79,  98,  80,  81,  0,   82,
+      171, 173, 0,   175, 0,   223, 0,   0,   226, 0,   228, 110, 164, 112, 0,   231, 113, 0,   233,
+      0,   234, 0,   0,   0,   195, 0,   0,   0,   236, 0,   238, 0,   0,   0,   8,   9,   10,  11,
+      12,  13,  14,  15,  16,  17,  18,  256, 19,  146, 20,  257, 0,   258, 115, 123, 131, 144, 0,
+      0,   261, 0,   262, 0,   0,   0,   202, 0,   203, 0,   0,   22,  23,  272, 207, 273, 208, 24,
+      0,   25,  26,  0,   0,   280, 92,  93,  94,  95,  96,  97,  206, 285, 92,  93,  94,  95,  96,
+      97,  0,   225, 98,  227, 0,   0,   229, 0,   230, 0,   98,  232, 0,   0,   87,  88,  89,  90,
+      211, 0,   235, 0,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  0,   19,  0,   20,
+      0,   255, 21,  87,  88,  89,  90,  0,   259, 0,   260, 48,  49,  50,  51,  52,  53,  0,   0,
+      0,   22,  23,  0,   0,   0,   0,   24,  0,   25,  26,  0,   274, 0,   0,   0,   54,  55,  279,
+      0,   0,   281, 8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  0,   19,  150, 20,  8,
+      9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  0,   19,  0,   20,  0,   0,   0,   0,   0,
+      22,  23,  0,   0,   0,   0,   24,  0,   25,  26,  0,   0,   0,   0,   0,   22,  23,  0,   0,
+      0,   0,   24,  278, 25,  26,  8,   9,   62,  63,  64,  13,  14,  65,  16,  17,  0,   0,   19,
+      0,   20,  92,  93,  94,  95,  96,  97,  0,   0,   0,   0,   0,   0,   212, 0,   213, 0,   98,
+      0,   0,   0,   22,  66,  239, 0,   240, 0,   24,  0,   25,  26,  92,  93,  94,  95,  96,  97,
+      0,   0,   0,   0,   92,  93,  94,  95,  96,  97,  98,  246, 0,   247, 0,   0,   0,   269, 0,
+      270, 98,  0,   0,   0,   0,   0,   0,   0,   0,   92,  93,  94,  95,  96,  97,  92,  93,  94,
+      95,  96,  97,  242, 0,   0,   0,   98,  0,   250, 0,   0,   0,   98,  0,   0,   0,   0,   0,
+      92,  93,  94,  95,  96,  97,  92,  93,  94,  95,  96,  97,  263, 0,   0,   0,   98,  0,   268,
+      0,   0,   0,   98,  0,   0,   0,   0,   0,   92,  93,  94,  95,  96,  97,  92,  93,  94,  95,
+      96,  97,  282, 0,   0,   0,   98,  0,   284, 0,   0,   0,   98,  0,   0,   0,   0,   0,   92,
+      93,  94,  95,  96,  97,  92,  93,  94,  95,  96,  97,  243, 0,   244, 0,   98,  0,   0,   245,
+      0,   0,   98,  0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+      164, 112, 199, 0,   113, 0,   200, 0,   0,   0,   0,   157, 32,  33,  34,  35,  36,  0,   100,
+      101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 0,   204, 113, 205, 37,  38,  0,
+      0,   0,   0,   158, 40,  41,  42,  43,  44,  0,   100, 101, 102, 103, 104, 105, 106, 107, 108,
+      109, 110, 111, 112, 0,   209, 113, 210, 45,  46,  0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 0,   214, 113, 215,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105,
+      106, 107, 108, 109, 110, 111, 112, 0,   252, 113, 253, 0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 0,
+      265, 113, 266, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102,
+      103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 0,   275, 113, 276, 0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+      164, 112, 267, 0,   113, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100,
+      101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 283, 0,   113, 0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
+      110, 164, 112, 163, 0,   113, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101,
+      102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 241, 0,   113, 0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112,
+      249, 0,   113, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104,
+      105, 106, 107, 108, 109, 110, 164, 112, 251, 0,   113, 0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 264, 0,   113,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107,
+      108, 109, 110, 164, 112, 271, 0,   113, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 277, 0,   113, 0,   0,   0,
+      0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+      164, 112, 286, 0,   113, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102,
+      103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 165, 0,   113, 0,   0,   0,   0,   0,   0,
+      0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 237, 0,   113,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
+      110, 164, 112, 99,  0,   113, 0,   0,   0,   0,   0,   0,   0,   100, 101, 102, 103, 104, 105,
+      106, 107, 108, 109, 110, 111, 112, 221, 0,   113, 92,  93,  94,  95,  96,  97,  0,   0,   0,
+      0,   0,   0,   0,   0,   0,   0,   98,  222, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
+      110, 164, 112, 0,   0,   113, 92,  93,  94,  95,  96,  97,  0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   98,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 0,   0,
+      113, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 164, 112, 0,   0,   113, 100, 101,
+      102, 103, 104, 105, 106, 107, 0,   0,   0,   0,   112, 0,   0,   113, 101, 102, 103, 104, 105,
+      106, 107, 108, 109, 110, 164, 112, 0,   0,   113, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+      164, 112, 0,   0,   113};
 
   const short Parser::yycheck_[] = {
-      4,   19,  0,   1,   20,  38,  39,  40,  41,  22,  23,  24,  25,  26,  27,  19,  20,  20, 22,
-      23,  24,  19,  38,  39,  40,  41,  22,  31,  32,  33,  34,  35,  36,  46,  47,  39,  40, 41,
-      42,  43,  44,  40,  41,  47,  48,  49,  50,  51,  52,  53,  22,  49,  56,  57,  58,  59, 60,
-      61,  20,  15,  64,  15,  17,  45,  82,  83,  16,  22,  15,  17,  32,  33,  34,  35,  36, 37,
-      28,  81,  30,  31,  31,  85,  86,  87,  88,  4,   48,  48,  38,  39,  40,  41,  22,  22, 98,
-      99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, -1,  16,  -1,  -1,  31, 14,
-      3,   16,  5,   6,   23,  8,   39,  28,  -1,  30,  31,  -1,  31,  -1,  47,  48,  -1,  32, 33,
-      34,  35,  36,  37,  56,  -1,  -1,  59,  60,  61,  -1,  -1,  14,  -1,  48,  152, -1,  -1, -1,
-      156, 58,  59,  60,  61,  -1,  -1,  -1,  -1,  -1,  81,  32,  33,  34,  35,  36,  37,  -1, 16,
-      90,  91,  92,  93,  94,  95,  96,  -1,  48,  85,  86,  3,   88,  5,   6,   190, 8,   -1, 193,
-      -1,  195, 38,  39,  40,  41,  200, -1,  -1,  203, -1,  205, -1,  -1,  109, -1,  210, -1, 212,
-      -1,  -1,  -1,  3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  227, 15,  16,  17, 231,
-      -1,  233, 40,  41,  42,  152, -1,  45,  240, -1,  242, -1,  -1,  -1,  -1,  14,  -1,  16, 16,
-      38,  39,  253, -1,  255, -1,  44,  -1,  46,  47,  -1,  -1,  263, -1,  32,  33,  34,  35, 36,
-      37,  271, 38,  39,  40,  41,  -1,  -1,  193, -1,  195, 48,  -1,  198, -1,  200, -1,  -1, 203,
-      -1,  -1,  -1,  -1,  -1,  209, -1,  3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13, -1,
-      15,  -1,  17,  -1,  227, 20,  -1,  -1,  -1,  -1,  -1,  234, -1,  236, 22,  23,  24,  25, 26,
-      27,  -1,  -1,  -1,  38,  39,  -1,  -1,  -1,  -1,  44,  -1,  46,  47,  -1,  257, -1,  -1, -1,
-      46,  47,  263, -1,  -1,  266, 3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  -1, 15,
-      16,  17,  3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  -1,  15,  -1,  17,  38, 39,
-      40,  41,  42,  38,  39,  45,  -1,  -1,  -1,  44,  -1,  46,  47,  -1,  -1,  -1,  -1,  -1, 38,
-      39,  -1,  -1,  -1,  -1,  44,  14,  46,  47,  3,   4,   5,   6,   7,   8,   9,   10,  11, 12,
-      -1,  -1,  15,  -1,  17,  32,  33,  34,  35,  36,  37,  -1,  -1,  -1,  -1,  -1,  -1,  14, -1,
-      16,  -1,  48,  -1,  -1,  -1,  38,  39,  14,  -1,  16,  -1,  44,  -1,  46,  47,  32,  33, 34,
-      35,  36,  37,  -1,  -1,  -1,  -1,  32,  33,  34,  35,  36,  37,  48,  14,  -1,  16,  -1, -1,
-      -1,  14,  -1,  16,  48,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  32,  33,  34,  35,  36, 37,
-      32,  33,  34,  35,  36,  37,  16,  -1,  -1,  -1,  48,  -1,  16,  -1,  -1,  -1,  48,  -1, -1,
-      -1,  -1,  -1,  32,  33,  34,  35,  36,  37,  32,  33,  34,  35,  36,  37,  16,  -1,  -1, -1,
-      48,  -1,  16,  -1,  -1,  -1,  48,  -1,  -1,  -1,  -1,  -1,  32,  33,  34,  35,  36,  37, 32,
-      33,  34,  35,  36,  37,  16,  -1,  -1,  -1,  48,  -1,  16,  -1,  -1,  -1,  48,  -1,  -1, -1,
-      -1,  -1,  32,  33,  34,  35,  36,  37,  32,  33,  34,  35,  36,  37,  14,  -1,  16,  -1, 48,
-      -1,  -1,  21,  -1,  -1,  48,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36, 37,
-      38,  39,  40,  41,  42,  14,  -1,  45,  -1,  18,  -1,  -1,  -1,  -1,  22,  23,  24,  25, 26,
-      27,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  14,  45, 16,
-      46,  47,  -1,  -1,  -1,  -1,  22,  23,  24,  25,  26,  27,  -1,  30,  31,  32,  33,  34, 35,
-      36,  37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,  46,  47,  -1,  -1,  -1,  -1,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42, -1,
-      14,  45,  16,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31, 32,
-      33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,  -1,  -1,  -1,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39, 40,
-      41,  42,  -1,  14,  45,  16,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, -1,
-      30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36, 37,
-      38,  39,  40,  41,  42,  14,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, -1,
-      -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  14,  -1,  45, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35, 36,
-      37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, -1,
-      -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38, 39,
-      40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30, 31,
-      32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41, 42,
-      16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33, 34,
-      35,  36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1, -1,
-      -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  16,  -1, 45,
-      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36, 37,
-      38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, -1,
-      30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  18,  -1,  45,  -1,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41, 42,
-      18,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35, 36,
-      37,  38,  39,  40,  41,  42,  20,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31, 32,
-      33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  29,  -1,  45,  32,  33,  34,  35,  36, 37,
-      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  48,  29,  30,  31,  32,  33,  34,  35, 36,
-      37,  38,  39,  40,  41,  42,  -1,  -1,  45,  32,  33,  34,  35,  36,  37,  -1,  -1,  -1, -1,
-      -1,  -1,  -1,  -1,  -1,  -1,  48,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40, 41,
-      42,  -1,  -1,  45,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1, -1,
-      45,  30,  31,  32,  33,  34,  35,  36,  37,  -1,  -1,  -1,  -1,  42,  -1,  -1,  45,  31, 32,
-      33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  -1,  45,  32,  33,  34,  35,  36, 37,
-      38,  39,  40,  41,  42,  -1,  -1,  45};
+      4,  19,  0,   1,   20,  38,  39,  40,  41,  22,  23,  24,  25,  26,  27,  19,  20,  20,  22,
+      23, 24,  19,  38,  39,  40,  41,  22,  31,  32,  33,  34,  35,  36,  46,  47,  39,  40,  41,
+      42, 43,  44,  40,  41,  47,  48,  49,  50,  51,  52,  53,  22,  49,  56,  57,  58,  59,  60,
+      61, 3,   20,  5,   6,   66,  8,   17,  17,  84,  85,  15,  22,  22,  32,  33,  34,  35,  36,
+      37, 15,  28,  83,  30,  31,  15,  87,  88,  89,  90,  48,  16,  4,   22,  23,  24,  25,  26,
+      27, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 38,  39,  40,  41,
+      46, 47,  31,  22,  38,  39,  40,  41,  42,  16,  39,  45,  23,  45,  31,  48,  22,  22,  47,
+      48, 31,  28,  -1,  30,  31,  -1,  -1,  56,  39,  58,  59,  60,  61,  -1,  -1,  -1,  47,  14,
+      -1, 157, 158, 159, 160, -1,  -1,  -1,  164, 58,  59,  60,  61,  -1,  -1,  -1,  83,  32,  33,
+      34, 35,  36,  37,  -1,  -1,  92,  93,  94,  95,  96,  97,  98,  3,   48,  5,   6,   -1,  8,
+      87, 88,  -1,  90,  -1,  199, -1,  -1,  202, -1,  204, 40,  41,  42,  -1,  209, 45,  -1,  212,
+      -1, 214, -1,  -1,  -1,  111, -1,  -1,  -1,  222, -1,  224, -1,  -1,  -1,  3,   4,   5,   6,
+      7,  8,   9,   10,  11,  12,  13,  239, 15,  16,  17,  243, -1,  245, 157, 158, 159, 160, -1,
+      -1, 252, -1,  254, -1,  -1,  -1,  14,  -1,  16,  -1,  -1,  38,  39,  265, 14,  267, 16,  44,
+      -1, 46,  47,  -1,  -1,  275, 32,  33,  34,  35,  36,  37,  16,  283, 32,  33,  34,  35,  36,
+      37, -1,  202, 48,  204, -1,  -1,  207, -1,  209, -1,  48,  212, -1,  -1,  38,  39,  40,  41,
+      16, -1,  221, -1,  3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  -1,  15,  -1,  17,
+      -1, 239, 20,  38,  39,  40,  41,  -1,  246, -1,  248, 22,  23,  24,  25,  26,  27,  -1,  -1,
+      -1, 38,  39,  -1,  -1,  -1,  -1,  44,  -1,  46,  47,  -1,  269, -1,  -1,  -1,  46,  47,  275,
+      -1, -1,  278, 3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  -1,  15,  16,  17,  3,
+      4,  5,   6,   7,   8,   9,   10,  11,  12,  13,  -1,  15,  -1,  17,  -1,  -1,  -1,  -1,  -1,
+      38, 39,  -1,  -1,  -1,  -1,  44,  -1,  46,  47,  -1,  -1,  -1,  -1,  -1,  38,  39,  -1,  -1,
+      -1, -1,  44,  14,  46,  47,  3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  -1,  -1,  15,
+      -1, 17,  32,  33,  34,  35,  36,  37,  -1,  -1,  -1,  -1,  -1,  -1,  14,  -1,  16,  -1,  48,
+      -1, -1,  -1,  38,  39,  14,  -1,  16,  -1,  44,  -1,  46,  47,  32,  33,  34,  35,  36,  37,
+      -1, -1,  -1,  -1,  32,  33,  34,  35,  36,  37,  48,  14,  -1,  16,  -1,  -1,  -1,  14,  -1,
+      16, 48,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  32,  33,  34,  35,  36,  37,  32,  33,  34,
+      35, 36,  37,  16,  -1,  -1,  -1,  48,  -1,  16,  -1,  -1,  -1,  48,  -1,  -1,  -1,  -1,  -1,
+      32, 33,  34,  35,  36,  37,  32,  33,  34,  35,  36,  37,  16,  -1,  -1,  -1,  48,  -1,  16,
+      -1, -1,  -1,  48,  -1,  -1,  -1,  -1,  -1,  32,  33,  34,  35,  36,  37,  32,  33,  34,  35,
+      36, 37,  16,  -1,  -1,  -1,  48,  -1,  16,  -1,  -1,  -1,  48,  -1,  -1,  -1,  -1,  -1,  32,
+      33, 34,  35,  36,  37,  32,  33,  34,  35,  36,  37,  14,  -1,  16,  -1,  48,  -1,  -1,  21,
+      -1, -1,  48,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
+      41, 42,  14,  -1,  45,  -1,  18,  -1,  -1,  -1,  -1,  22,  23,  24,  25,  26,  27,  -1,  30,
+      31, 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,  46,  47,  -1,
+      -1, -1,  -1,  22,  23,  24,  25,  26,  27,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,
+      39, 40,  41,  42,  -1,  14,  45,  16,  46,  47,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,
+      36, 37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,
+      14, 45,  16,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,
+      33, 34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  14,  45,  16,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
+      41, 42,  14,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,
+      31, 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  14,  -1,  45,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,
+      40, 41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,
+      32, 33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,
+      16, -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,
+      35, 36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,
+      38, 39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      30, 31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  16,  -1,  45,  -1,  -1,  -1,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
+      41, 42,  16,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,
+      33, 34,  35,  36,  37,  38,  39,  40,  41,  42,  18,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  18,  -1,  45,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,
+      40, 41,  42,  20,  -1,  45,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  30,  31,  32,  33,  34,  35,
+      36, 37,  38,  39,  40,  41,  42,  29,  -1,  45,  32,  33,  34,  35,  36,  37,  -1,  -1,  -1,
+      -1, -1,  -1,  -1,  -1,  -1,  -1,  48,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,
+      40, 41,  42,  -1,  -1,  45,  32,  33,  34,  35,  36,  37,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      -1, -1,  -1,  48,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  -1,
+      45, 30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  -1,  -1,  45,  30,  31,
+      32, 33,  34,  35,  36,  37,  -1,  -1,  -1,  -1,  42,  -1,  -1,  45,  31,  32,  33,  34,  35,
+      36, 37,  38,  39,  40,  41,  42,  -1,  -1,  45,  32,  33,  34,  35,  36,  37,  38,  39,  40,
+      41, 42,  -1,  -1,  45};
 
   const unsigned char Parser::yystos_[] = {
       0,  51, 0,  1,  19, 49, 52, 20, 3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 15, 17, 20, 38,
       39, 44, 46, 47, 53, 54, 55, 56, 22, 23, 24, 25, 26, 27, 46, 47, 22, 23, 24, 25, 26, 27, 46,
-      47, 22, 22, 23, 24, 25, 26, 27, 46, 47, 22, 17, 22, 15, 15, 15, 5,  10, 39, 53, 55, 56, 56,
-      56, 54, 56, 56, 3,  5,  6,  8,  3,  5,  6,  8,  28, 30, 31, 20, 38, 39, 40, 41, 20, 32, 33,
-      34, 35, 36, 37, 48, 20, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 54, 55, 56,
-      56, 56, 56, 56, 56, 55, 56, 56, 56, 56, 56, 56, 55, 56, 55, 56, 56, 56, 56, 56, 56, 55, 56,
-      56, 54, 56, 16, 54, 55, 56, 16, 54, 55, 56, 54, 55, 56, 22, 56, 16, 16, 41, 18, 55, 56, 53,
-      56, 53, 54, 54, 56, 54, 56, 55, 55, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56,
-      56, 56, 54, 56, 56, 56, 14, 18, 16, 14, 16, 14, 16, 16, 14, 16, 14, 16, 16, 14, 16, 14, 16,
-      56, 56, 29, 29, 56, 22, 55, 56, 55, 56, 55, 55, 56, 55, 56, 56, 55, 56, 18, 56, 14, 16, 16,
-      16, 14, 16, 21, 14, 16, 14, 16, 16, 16, 14, 16, 22, 55, 56, 56, 56, 55, 55, 56, 56, 16, 16,
-      14, 16, 14, 16, 14, 16, 16, 56, 56, 55, 14, 16, 16, 14, 55, 56, 55, 16, 14, 16, 56, 16};
+      47, 22, 22, 23, 24, 25, 26, 27, 46, 47, 22, 17, 22, 15, 15, 15, 5,  6,  7,  10, 39, 53, 55,
+      56, 56, 56, 54, 56, 56, 3,  5,  6,  8,  3,  5,  6,  8,  28, 30, 31, 20, 38, 39, 40, 41, 20,
+      32, 33, 34, 35, 36, 37, 48, 20, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 54,
+      55, 56, 56, 56, 56, 56, 56, 54, 55, 56, 56, 56, 56, 56, 56, 54, 55, 56, 55, 56, 56, 56, 56,
+      56, 56, 55, 56, 56, 54, 55, 56, 16, 54, 55, 56, 16, 54, 55, 56, 54, 55, 56, 22, 22, 22, 22,
+      56, 16, 16, 41, 18, 55, 56, 53, 56, 53, 54, 56, 54, 56, 54, 56, 55, 55, 55, 55, 55, 55, 55,
+      56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 54, 56, 56, 56, 14, 18, 16, 14, 16, 14, 16, 16,
+      14, 16, 14, 16, 16, 14, 16, 14, 16, 56, 56, 56, 56, 56, 29, 29, 56, 22, 55, 56, 55, 56, 55,
+      55, 56, 55, 56, 56, 55, 56, 18, 56, 14, 16, 16, 16, 14, 16, 21, 14, 16, 14, 16, 16, 16, 14,
+      16, 22, 55, 56, 56, 56, 55, 55, 56, 56, 16, 16, 14, 16, 14, 16, 14, 16, 16, 56, 56, 55, 14,
+      16, 16, 14, 55, 56, 55, 16, 14, 16, 56, 16};
 
   const unsigned char Parser::yyr1_[] = {
       0,  50, 51, 51, 52, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
-      53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 55,
-      55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56,
+      53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
+      54, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 56, 56,
       56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
       56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
-      56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56};
+      56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56};
 
   const unsigned char Parser::yyr2_[] = {
-      0, 2, 0, 2, 1, 3,  3,  3,  2,  2, 3, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-      3, 1, 4, 6, 6, 8,  6,  4,  4,  3, 3, 3, 2, 3, 3, 3, 3, 3, 1, 1, 1, 3, 3, 3, 3, 3, 4,
-      3, 4, 4, 3, 6, 12, 8,  8,  6,  5, 1, 2, 2, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2,
-      2, 2, 2, 3, 3, 3,  3,  3,  3,  3, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 6, 6,
+      0, 2, 0, 2, 1, 3,  3,  3,  2,  2, 3, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+      1, 4, 6, 6, 8, 6,  4,  4,  3,  3, 3, 3, 3, 2, 3, 3, 3, 3, 3, 1, 1, 1, 3, 3, 3, 3, 3, 3,
+      4, 3, 4, 4, 3, 6,  12, 8,  8,  6, 5, 1, 2, 2, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+      2, 2, 2, 2, 3, 3,  3,  3,  3,  3, 3, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 6, 6,
       6, 8, 6, 8, 8, 10, 10, 12, 14, 3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 1, 5, 4, 6, 6, 8};
 
   // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
@@ -2391,14 +2441,14 @@ namespace SEAMS {
 
 #if SEAMSDEBUG
   const unsigned short Parser::yyrline_[] = {
-      0,   145, 145, 146, 149, 150, 157, 161, 162, 163, 166, 167, 168, 169, 170, 171, 172,
-      173, 174, 175, 176, 177, 180, 181, 182, 183, 184, 185, 187, 188, 194, 200, 206, 212,
-      218, 224, 230, 233, 235, 243, 245, 253, 254, 255, 256, 265, 266, 267, 268, 270, 273,
-      277, 278, 279, 285, 291, 297, 303, 304, 310, 316, 322, 328, 334, 336, 337, 338, 339,
-      340, 341, 342, 343, 344, 345, 347, 350, 351, 352, 353, 354, 359, 360, 361, 362, 363,
-      364, 365, 366, 367, 368, 369, 371, 373, 376, 379, 382, 385, 387, 390, 393, 396, 399,
-      406, 413, 420, 427, 434, 441, 448, 455, 462, 468, 474, 480, 486, 492, 498, 504, 505,
-      506, 507, 514, 521, 522, 523, 526, 527, 530, 531, 532, 533, 534, 556};
+      0,   145, 145, 146, 149, 150, 157, 161, 162, 163, 166, 167, 168, 169, 170, 171, 172, 173,
+      174, 175, 176, 177, 180, 181, 182, 183, 184, 185, 187, 188, 194, 200, 206, 212, 218, 224,
+      230, 234, 238, 241, 243, 251, 253, 261, 262, 263, 264, 273, 274, 275, 276, 278, 281, 285,
+      290, 291, 292, 298, 304, 310, 316, 317, 323, 329, 335, 341, 347, 349, 350, 351, 352, 353,
+      354, 355, 356, 357, 358, 360, 363, 368, 369, 370, 371, 372, 377, 378, 379, 380, 381, 382,
+      383, 384, 385, 386, 387, 389, 391, 394, 397, 400, 403, 405, 408, 411, 414, 417, 424, 431,
+      438, 445, 452, 459, 466, 473, 480, 486, 492, 498, 504, 510, 516, 522, 523, 524, 525, 532,
+      539, 540, 541, 544, 545, 548, 549, 550, 551, 552, 574};
 
   // Print the state stack on the debug stream.
   void Parser::yystack_print_()
@@ -2453,7 +2503,8 @@ namespace SEAMS {
   }
 
 } // namespace SEAMS
-#line 2494 "apr_parser.cc" // lalr1.cc:1242
-#line 579 "aprepro.yy"     // lalr1.cc:1243
+#line 2541 "apr_parser.cc"
+
+#line 597 "aprepro.yy"
 
 void SEAMS::Parser::error(const std::string &m) { aprepro.error(m); }
diff --git a/packages/seacas/libraries/aprepro_lib/apr_scanner.cc b/packages/seacas/libraries/aprepro_lib/apr_scanner.cc
index 8fc93a4d3108..4b27323fd02f 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_scanner.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_scanner.cc
@@ -2312,7 +2312,7 @@ yyFlexLexer::yyFlexLexer(std::istream *arg_yyin, std::ostream *arg_yyout)
 {
   yyin          = arg_yyin;
   yyout         = arg_yyout;
-  yy_c_buf_p    = 0;
+  yy_c_buf_p    = nullptr;
   yy_init       = 0;
   yy_start      = 0;
   yy_flex_debug = 0;
@@ -2328,11 +2328,11 @@ yyFlexLexer::yyFlexLexer(std::istream *arg_yyin, std::ostream *arg_yyout)
   yy_start_stack_ptr = yy_start_stack_depth = 0;
   yy_start_stack                            = NULL;
 
-  yy_buffer_stack     = 0;
+  yy_buffer_stack     = nullptr;
   yy_buffer_stack_top = 0;
   yy_buffer_stack_max = 0;
 
-  yy_state_buf = 0;
+  yy_state_buf = nullptr;
 }
 
 /* The contents of this function are C++ specific, so the () macro is not used.
@@ -2469,7 +2469,7 @@ int yyFlexLexer::yy_get_next_buffer()
       }
       else
         /* Can't grow it, we don't own it. */
-        b->yy_ch_buf = 0;
+        b->yy_ch_buf = nullptr;
 
       if (!b->yy_ch_buf)
         YY_FATAL_ERROR("fatal error - scanner input buffer overflow");
@@ -3175,9 +3175,9 @@ namespace SEAMS {
   {
     std::fstream *yytmp = nullptr;
     if (must_exist)
-      yytmp = aprepro.open_file(filename.c_str(), "r");
+      yytmp = aprepro.open_file(filename, "r");
     else
-      yytmp = aprepro.check_open_file(filename.c_str(), "r");
+      yytmp = aprepro.check_open_file(filename, "r");
 
     if (yytmp) {
       if (yyin && !yy_init) {
diff --git a/packages/seacas/libraries/aprepro_lib/aprepro.ll b/packages/seacas/libraries/aprepro_lib/aprepro.ll
index b8ee0e7a9778..450c11ff603e 100644
--- a/packages/seacas/libraries/aprepro_lib/aprepro.ll
+++ b/packages/seacas/libraries/aprepro_lib/aprepro.ll
@@ -717,9 +717,9 @@ integer {D}+({E})?
   {
     std::fstream *yytmp = nullptr;
     if (must_exist)
-      yytmp = aprepro.open_file(filename.c_str(), "r");
+      yytmp = aprepro.open_file(filename, "r");
     else
-      yytmp = aprepro.check_open_file(filename.c_str(), "r");
+      yytmp = aprepro.check_open_file(filename, "r");
 
     if (yytmp) {
       if (yyin && !yy_init) {
diff --git a/packages/seacas/libraries/aprepro_lib/aprepro.yy b/packages/seacas/libraries/aprepro_lib/aprepro.yy
index f6b9bb67e940..425ed7765dd2 100644
--- a/packages/seacas/libraries/aprepro_lib/aprepro.yy
+++ b/packages/seacas/libraries/aprepro_lib/aprepro.yy
@@ -1,23 +1,23 @@
 // Copyright (c) 2014-2017 National Technology & Engineering Solutions
 // of Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
 // NTESS, the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
-// 
+//
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
-//       with the distribution.  
-// 
+//       with the distribution.
+//
 //     * Neither the name of NTESS nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -29,7 +29,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
+//
 %{
 #include "aprepro.h"
 #include "apr_util.h"
@@ -104,12 +104,12 @@ namespace SEAMS {
 %token  <tptr>  FNCT
 %token  <tptr>  SFNCT
 %token  <tptr>  AFNCT
-%type   <val>   exp 
-%type   <arrval> aexp 
+%type   <val>   exp
+%type   <arrval> aexp
 %type   <val>   bool
 %type   <string>        sexp
 
-%token END 0 "end of file" 
+%token END 0 "end of file"
 %token COMMA LPAR RPAR LBRACK RBRACK LBRACE RBRACE SEMI
 /* Precedence (Lowest to Highest) and associativity */
 %right  EQUAL
@@ -227,26 +227,34 @@ aexp:   AVAR                    { $$ = $1->value.avar;}
           else
             yyerrok;
         }
-        | AVAR EQUAL aexp       { $$ = $3; delete $1->value.avar; $1->value.avar = $3; 
+        | SVAR EQUAL aexp       { $$ = $3;
+                                  $1->value.avar = $3;
+                                  redefined_warning(aprepro, $1);
+                                  set_type(aprepro, $1, token::AVAR);           }
+        | VAR EQUAL aexp        { $$ = $3;
+                                  $1->value.avar= $3;
+                                  redefined_warning(aprepro, $1);
+                                  set_type(aprepro, $1, token::AVAR);           }
+        | AVAR EQUAL aexp       { $$ = $3; delete $1->value.avar; $1->value.avar = $3;
                                   redefined_warning(aprepro, $1);
                                   set_type(aprepro, $1, token::AVAR); }
-        | UNDVAR EQUAL aexp     { $$ = $3; $1->value.avar = $3; 
+        | UNDVAR EQUAL aexp     { $$ = $3; $1->value.avar = $3;
                                   set_type(aprepro, $1, token::AVAR); }
         | aexp PLU aexp         { if ($1->cols == $3->cols && $1->rows == $3->rows ) {
-                                     $$ = array_add($1, $3); 
+                                     $$ = array_add($1, $3);
                                   }
                                   else {
-                                    yyerror(aprepro, "Arrays do not have same row and column count"); 
+                                    yyerror(aprepro, "Arrays do not have same row and column count");
                                     yyerrok;
                                   }
                                 }
         | SUB aexp %prec UNARY  { $$ = array_scale($2, -1.0);           }
 
         | aexp SUB aexp         { if ($1->cols == $3->cols && $1->rows == $3->rows ) {
-                                     $$ = array_sub($1, $3); 
+                                     $$ = array_sub($1, $3);
                                   }
                                   else {
-                                    yyerror(aprepro, "Arrays do not have same row and column count"); 
+                                    yyerror(aprepro, "Arrays do not have same row and column count");
                                     yyerrok;
                                   }
                                 }
@@ -257,7 +265,7 @@ aexp:   AVAR                    { $$ = $1->value.avar;}
                                     $$ = array_mult($1, $3);
                                   }
                                   else {
-                                    yyerror(aprepro, "Column count of first array does not match row count of second array"); 
+                                    yyerror(aprepro, "Column count of first array does not match row count of second array");
                                     yyerrok;
                                   }
                                 }
@@ -267,12 +275,17 @@ sexp:     QSTRING               { $$ = $1;                              }
         | IMMSVAR               { $$ = (char*)$1->value.svar.c_str();                   }
         | UNDVAR EQUAL sexp     { $$ = $3; $1->value.svar = $3;
                                   set_type(aprepro, $1, Parser::token::SVAR);   }
-        | SVAR EQUAL sexp       { $$ = $3; 
+        | SVAR EQUAL sexp       { $$ = $3;
                                   $1->value.svar = $3;
                                   redefined_warning(aprepro, $1);          }
-        | VAR EQUAL sexp        { $$ = $3; 
+        | VAR EQUAL sexp        { $$ = $3;
+                                  $1->value.svar= $3;
+                                  redefined_warning(aprepro, $1);
+                                  set_type(aprepro, $1, token::SVAR);           }
+        | AVAR EQUAL sexp       { $$ = $3;
+	                          delete $1->value.avar;
                                   $1->value.svar= $3;
-                                  redefined_warning(aprepro, $1);          
+                                  redefined_warning(aprepro, $1);
                                   set_type(aprepro, $1, token::SVAR);           }
         | IMMSVAR EQUAL sexp    { $$ = (char*)$1->value.svar.c_str(); immutable_modify(aprepro, $1); }
         | IMMVAR EQUAL sexp     { immutable_modify(aprepro, $1); YYERROR; }
@@ -345,15 +358,20 @@ exp:      NUM                   { $$ = $1;                              }
         | VAR EQUAL exp         { $$ = $3; $1->value.var = $3;
                                   redefined_warning(aprepro, $1);          }
         | SVAR EQUAL exp                { $$ = $3; $1->value.var = $3;
-                                  redefined_warning(aprepro, $1);          
+                                  redefined_warning(aprepro, $1);
                                   set_type(aprepro, $1, token::VAR);                    }
+        | AVAR EQUAL exp        { $$ = $3;
+	                          delete $1->value.avar;
+                                  $1->value.var= $3;
+                                  redefined_warning(aprepro, $1);
+                                  set_type(aprepro, $1, token::VAR);           }
         | VAR EQ_PLUS exp       { $1->value.var += $3; $$ = $1->value.var; }
         | VAR EQ_MINUS exp      { $1->value.var -= $3; $$ = $1->value.var; }
         | VAR EQ_TIME exp       { $1->value.var *= $3; $$ = $1->value.var; }
         | VAR EQ_DIV exp        { $1->value.var /= $3; $$ = $1->value.var; }
         | VAR EQ_POW exp        { reset_error();
-                                  $1->value.var = std::pow($1->value.var,$3); 
-                                  $$ = $1->value.var; 
+                                  $1->value.var = std::pow($1->value.var,$3);
+                                  $$ = $1->value.var;
                                   SEAMS::math_error(aprepro, "Power");
                                 }
         | INC IMMVAR            { $$ = $2->value.var; immutable_modify(aprepro, $2);  }
@@ -370,35 +388,35 @@ exp:      NUM                   { $$ = $1;                              }
 
         | UNDVAR                { $$ = $1->value.var;
                                   undefined_error(aprepro, $1->name);          }
-        | INC UNDVAR            { $$ = ++($2->value.var);               
+        | INC UNDVAR            { $$ = ++($2->value.var);
                                   set_type(aprepro, $2, token::VAR);
                                   undefined_error(aprepro, $2->name);          }
-        | DEC UNDVAR            { $$ = --($2->value.var);               
+        | DEC UNDVAR            { $$ = --($2->value.var);
                                   set_type(aprepro, $2, token::VAR);
                                   undefined_error(aprepro, $2->name);          }
-        | UNDVAR INC            { $$ = ($1->value.var)++;               
+        | UNDVAR INC            { $$ = ($1->value.var)++;
                                   set_type(aprepro, $1, token::VAR);
                                   undefined_error(aprepro, $1->name);          }
-        | UNDVAR DEC            { $$ = ($1->value.var)--;               
+        | UNDVAR DEC            { $$ = ($1->value.var)--;
                                   set_type(aprepro, $1, token::VAR);
                                   undefined_error(aprepro, $1->name);          }
         | UNDVAR EQUAL exp      { $$ = $3; $1->value.var = $3;
                                   set_type(aprepro, $1, token::VAR);                      }
-        | UNDVAR EQ_PLUS exp    { $1->value.var += $3; $$ = $1->value.var; 
+        | UNDVAR EQ_PLUS exp    { $1->value.var += $3; $$ = $1->value.var;
                                   set_type(aprepro, $1, token::VAR);
                                   undefined_error(aprepro, $1->name);          }
-        | UNDVAR EQ_MINUS exp   { $1->value.var -= $3; $$ = $1->value.var; 
+        | UNDVAR EQ_MINUS exp   { $1->value.var -= $3; $$ = $1->value.var;
                                   set_type(aprepro, $1, token::VAR);
                                   undefined_error(aprepro, $1->name);          }
-        | UNDVAR EQ_TIME exp    { $1->value.var *= $3; $$ = $1->value.var; 
+        | UNDVAR EQ_TIME exp    { $1->value.var *= $3; $$ = $1->value.var;
                                   set_type(aprepro, $1, token::VAR);
                                   undefined_error(aprepro, $1->name);          }
-        | UNDVAR EQ_DIV exp     { $1->value.var /= $3; $$ = $1->value.var; 
+        | UNDVAR EQ_DIV exp     { $1->value.var /= $3; $$ = $1->value.var;
                                   set_type(aprepro, $1, token::VAR);
                                   undefined_error(aprepro, $1->name);          }
         | UNDVAR EQ_POW exp     { reset_error();
-                                  $1->value.var = std::pow($1->value.var,$3); 
-                                  $$ = $1->value.var; 
+                                  $1->value.var = std::pow($1->value.var,$3);
+                                  $$ = $1->value.var;
                                   set_type(aprepro, $1, token::VAR);
                                   SEAMS::math_error(aprepro, "Power");
                                   undefined_error(aprepro, $1->name);          }
@@ -406,7 +424,7 @@ exp:      NUM                   { $$ = $1;                              }
         | FNCT LPAR RPAR        {
           if (arg_check($1, $1->value.fnctptr == NULL))
             $$ = (*($1->value.fnctptr))();
-          else 
+          else
             $$ = 0.0;
           }
 
@@ -436,7 +454,7 @@ exp:      NUM                   { $$ = $1;                              }
               $$ = (*($1->value.fnctptr_cd))($3, $5);
             else
               $$ = 0.0;
-          }         
+          }
 
         | FNCT LPAR exp COMMA sexp RPAR {
           if (arg_check($1, $1->value.fnctptr_dc == NULL))
@@ -506,7 +524,7 @@ exp:      NUM                   { $$ = $1;                              }
         | exp TIM exp           { $$ = $1 * $3;                         }
         | exp DIV exp           { if ($3 == 0.)
                                     {
-                                      yyerror(aprepro, "Zero divisor"); 
+                                      yyerror(aprepro, "Zero divisor");
                                       yyerrok;
                                     }
                                   else
@@ -517,11 +535,11 @@ exp:      NUM                   { $$ = $1;                              }
                                       yyerrok;
                                     }
                                   else
-                                    $$ = (int)$1 % (int)$3;             }  
+                                    $$ = (int)$1 % (int)$3;             }
         | SUB exp %prec UNARY   { $$ = -$2;                             }
         | PLU exp %prec UNARY   { $$ =  $2;                             }
         | exp POW exp           { reset_error();
-                                  $$ = std::pow($1, $3); 
+                                  $$ = std::pow($1, $3);
                                   SEAMS::math_error(aprepro, "Power");                  }
         | LPAR exp RPAR         { $$ = $2;                              }
         | LBRACK exp RBRACK     { reset_error();
@@ -531,12 +549,12 @@ exp:      NUM                   { $$ = $1;                              }
         | bool QUEST exp COLON exp   { $$ = ($1) ? ($3) : ($5);              }
         | AVAR LBRACK exp RBRACK { $$ = array_value($1->value.avar, $3, 0); }
         | AVAR LBRACK exp COMMA exp RBRACK { $$ = array_value($1->value.avar, $3, $5); }
-        | AVAR LBRACK exp RBRACK EQUAL exp 
+        | AVAR LBRACK exp RBRACK EQUAL exp
                                   { $$ = $6;
                                     array *arr = $1->value.avar;
                                     int cols = arr->cols;
                                     if (cols > 1) {
-                                      yyerror(aprepro, "Cannot use [index] array access with multi-column array"); 
+                                      yyerror(aprepro, "Cannot use [index] array access with multi-column array");
                                       yyerrok;
                                     }
                                     int rows = arr->rows;
@@ -549,11 +567,11 @@ exp:      NUM                   { $$ = $1;                              }
                                       $1->value.avar->data[offset] = $6;
                                     }
                                     else {
-                                      yyerror(aprepro, "Row or Column index out of range"); 
+                                      yyerror(aprepro, "Row or Column index out of range");
                                       yyerrok;
                                     }
                                   }
-        | AVAR LBRACK exp COMMA exp RBRACK EQUAL exp 
+        | AVAR LBRACK exp COMMA exp RBRACK EQUAL exp
                                   { $$ = $8;
                                     array *arr = $1->value.avar;
                                     int cols = arr->cols;
@@ -569,7 +587,7 @@ exp:      NUM                   { $$ = $1;                              }
                                       $1->value.avar->data[offset] = $8;
                                     }
                                     else {
-                                      yyerror(aprepro, "Row or Column index out of range"); 
+                                      yyerror(aprepro, "Row or Column index out of range");
                                       yyerrok;
                                     }
                                   }
diff --git a/packages/seacas/libraries/aprepro_lib/aprepro_parser.h b/packages/seacas/libraries/aprepro_lib/aprepro_parser.h
index ed831cd564fe..437a05b196f2 100644
--- a/packages/seacas/libraries/aprepro_lib/aprepro_parser.h
+++ b/packages/seacas/libraries/aprepro_lib/aprepro_parser.h
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.3.2.
+// A Bison parser, made by GNU Bison 3.4.
 
 // Skeleton interface for Bison LALR(1) parsers in C++
 
@@ -153,7 +153,7 @@
 #endif /* ! defined SEAMSDEBUG */
 
 namespace SEAMS {
-#line 165 "aprepro_parser.h" // lalr1.cc:417
+#line 164 "aprepro_parser.h"
 
   /// A Bison parser.
   class Parser
@@ -162,14 +162,14 @@ namespace SEAMS {
 #ifndef SEAMSSTYPE
     /// Symbol semantic values.
     union semantic_type {
-#line 89 "aprepro.yy" // lalr1.cc:417
+#line 89 "aprepro.yy"
 
-      double         val;    /* For returning numbers.          */
-      struct symrec *tptr;   /* For returning symbol-table pointers     */
-      char *         string; /* For returning quoted strings            */
+      double         val;    /* For returning numbers.               */
+      struct symrec *tptr;   /* For returning symbol-table pointers  */
+      char *         string; /* For returning quoted strings         */
       struct array * arrval; /* For returning arrays                 */
 
-#line 184 "aprepro_parser.h" // lalr1.cc:417
+#line 184 "aprepro_parser.h"
     };
 #else
     typedef SEAMSSTYPE semantic_type;
@@ -378,7 +378,7 @@ namespace SEAMS {
     void error(const syntax_error &err);
 
   private:
-    /// This class is not copyable.
+    /// This class is not copiable.
     Parser(const Parser &);
     Parser &operator=(const Parser &);
 
@@ -631,7 +631,7 @@ namespace SEAMS {
     /// Constants.
     enum {
       yyeof_     = 0,
-      yylast_    = 1299, ///< Last index in yytable_.
+      yylast_    = 1315, ///< Last index in yytable_.
       yynnts_    = 7,    ///< Number of nonterminal symbols.
       yyfinal_   = 2,    ///< Termination state number.
       yyterror_  = 1,
@@ -644,6 +644,6 @@ namespace SEAMS {
   };
 
 } // namespace SEAMS
-#line 728 "aprepro_parser.h" // lalr1.cc:417
+#line 728 "aprepro_parser.h"
 
 #endif // !YY_SEAMS_APREPRO_PARSER_H_INCLUDED
diff --git a/packages/seacas/libraries/aprepro_lib/stack.hh b/packages/seacas/libraries/aprepro_lib/stack.hh
new file mode 100644
index 000000000000..b9361d62c6cb
--- /dev/null
+++ b/packages/seacas/libraries/aprepro_lib/stack.hh
@@ -0,0 +1,157 @@
+// A Bison parser, made by GNU Bison 3.0.4.
+
+// Stack handling for Bison parsers in C++
+
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file stack.hh
+ ** Define the SEAMS::stack class.
+ */
+
+#ifndef YY_SEAMS_STACK_HH_INCLUDED
+# define YY_SEAMS_STACK_HH_INCLUDED
+
+# include <vector>
+
+
+namespace SEAMS {
+#line 46 "stack.hh" // stack.hh:132
+  template <class T, class S = std::vector<T> >
+  class stack
+  {
+  public:
+    // Hide our reversed order.
+    typedef typename S::reverse_iterator iterator;
+    typedef typename S::const_reverse_iterator const_iterator;
+
+    stack ()
+      : seq_ ()
+    {
+      seq_.reserve (200);
+    }
+
+    stack (unsigned int n)
+      : seq_ (n)
+    {}
+
+    inline
+    T&
+    operator[] (unsigned int i)
+    {
+      return seq_[seq_.size () - 1 - i];
+    }
+
+    inline
+    const T&
+    operator[] (unsigned int i) const
+    {
+      return seq_[seq_.size () - 1 - i];
+    }
+
+    /// Steal the contents of \a t.
+    ///
+    /// Close to move-semantics.
+    inline
+    void
+    push (T& t)
+    {
+      seq_.push_back (T());
+      operator[](0).move (t);
+    }
+
+    inline
+    void
+    pop (unsigned int n = 1)
+    {
+      for (; n; --n)
+        seq_.pop_back ();
+    }
+
+    void
+    clear ()
+    {
+      seq_.clear ();
+    }
+
+    inline
+    typename S::size_type
+    size () const
+    {
+      return seq_.size ();
+    }
+
+    inline
+    const_iterator
+    begin () const
+    {
+      return seq_.rbegin ();
+    }
+
+    inline
+    const_iterator
+    end () const
+    {
+      return seq_.rend ();
+    }
+
+  private:
+    stack (const stack&);
+    stack& operator= (const stack&);
+    /// The wrapped container.
+    S seq_;
+  };
+
+  /// Present a slice of the top of a stack.
+  template <class T, class S = stack<T> >
+  class slice
+  {
+  public:
+    slice (const S& stack, unsigned int range)
+      : stack_ (stack)
+      , range_ (range)
+    {}
+
+    inline
+    const T&
+    operator [] (unsigned int i) const
+    {
+      return stack_[range_ - i];
+    }
+
+  private:
+    const S& stack_;
+    unsigned int range_;
+  };
+
+
+} // SEAMS
+#line 156 "stack.hh" // stack.hh:132
+
+#endif // !YY_SEAMS_STACK_HH_INCLUDED
diff --git a/packages/seacas/libraries/exodus/src/ex_create.c b/packages/seacas/libraries/exodus/src/ex_create.c
index d4ca842e766e..2c93ecbf81a2 100644
--- a/packages/seacas/libraries/exodus/src/ex_create.c
+++ b/packages/seacas/libraries/exodus/src/ex_create.c
@@ -159,8 +159,8 @@ exoid = ex_create ("test.exo"       \comment{filename path}
  */
 int ex_create_int(const char *path, int cmode, int *comp_ws, int *io_ws, int run_version)
 {
-  int  exoid;
-  int  status;
+  int  exoid  = 0;
+  int  status = 0;
   char errmsg[MAX_ERR_LENGTH];
   int  nc_mode = 0;
 
@@ -185,7 +185,7 @@ int ex_create_int(const char *path, int cmode, int *comp_ws, int *io_ws, int run
       snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s", path);
     }
 #endif
-    ex_err_fn(exoid, __func__, errmsg, status);
+    ex_err(__func__, errmsg, status);
     EX_FUNC_LEAVE(EX_FATAL);
   }
 
diff --git a/packages/seacas/libraries/exodus/src/ex_create_par.c b/packages/seacas/libraries/exodus/src/ex_create_par.c
index 7cf797c6c138..8d5d6734f0ad 100644
--- a/packages/seacas/libraries/exodus/src/ex_create_par.c
+++ b/packages/seacas/libraries/exodus/src/ex_create_par.c
@@ -165,8 +165,8 @@ exoid = ex_create ("test.exo"       \comment{filename path}
 int ex_create_par_int(const char *path, int cmode, int *comp_ws, int *io_ws, MPI_Comm comm,
                       MPI_Info info, int run_version)
 {
-  int  exoid;
-  int  status;
+  int  exoid  = -1;
+  int  status = 0;
   char errmsg[MAX_ERR_LENGTH];
   int  nc_mode = 0;
 
@@ -181,7 +181,7 @@ int ex_create_par_int(const char *path, int cmode, int *comp_ws, int *io_ws, MPI
            "EXODUS: ERROR: Parallel output requires the netcdf-4 and/or "
            "pnetcdf library format, but this netcdf library does not "
            "support either.\n");
-  ex_err_fn(exoid, __func__, errmsg, EX_BADPARAM);
+  ex_err(__func__, errmsg, EX_BADPARAM);
   EX_FUNC_LEAVE(EX_FATAL);
 #endif
 
@@ -201,7 +201,7 @@ int ex_create_par_int(const char *path, int cmode, int *comp_ws, int *io_ws, MPI
       snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s", path);
     }
 #endif
-    ex_err_fn(exoid, __func__, errmsg, status);
+    ex_err(__func__, errmsg, status);
     EX_FUNC_LEAVE(EX_FATAL);
   }
 
diff --git a/packages/seacas/libraries/exodus/src/ex_get_time.c b/packages/seacas/libraries/exodus/src/ex_get_time.c
index 78bb3d1bb2ae..0bc5aa7ee395 100644
--- a/packages/seacas/libraries/exodus/src/ex_get_time.c
+++ b/packages/seacas/libraries/exodus/src/ex_get_time.c
@@ -85,7 +85,12 @@ int ex_get_time(int exoid, int time_step, void *time_value)
   struct ex__file_item *file = NULL;
 
   EX_FUNC_ENTER();
-  ex__check_valid_file_id(exoid, __func__);
+
+  file = ex__find_file_item(exoid);
+  if (!file) {
+    snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unknown file id %d.", exoid);
+    ex_err_fn(exoid, __func__, errmsg, EX_BADFILEID);
+  }
 
   int num_time_steps = ex_inquire_int(exoid, EX_INQ_TIME);
 
@@ -112,12 +117,6 @@ int ex_get_time(int exoid, int time_step, void *time_value)
     EX_FUNC_LEAVE(EX_FATAL);
   }
 
-  file = ex__find_file_item(exoid);
-  if (!file) {
-    snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unknown file id %d.", exoid);
-    ex_err_fn(exoid, __func__, errmsg, EX_BADFILEID);
-  }
-
   varid = file->time_varid;
   if (varid < 0) {
     /* inquire previously defined variable */
diff --git a/packages/seacas/libraries/exodus/src/ex_open.c b/packages/seacas/libraries/exodus/src/ex_open.c
index ec6603432b8c..f3b760c3f0c5 100644
--- a/packages/seacas/libraries/exodus/src/ex_open.c
+++ b/packages/seacas/libraries/exodus/src/ex_open.c
@@ -129,19 +129,20 @@ exoid = ex_open ("test.exo",     \co{filename path}
 int ex_open_int(const char *path, int mode, int *comp_ws, int *io_ws, float *version,
                 int run_version)
 {
-  int     exoid = -1;
-  int     status, stat_att, stat_dim;
-  nc_type att_type = NC_NAT;
-  size_t  att_len  = 0;
-  int     old_fill;
-  int     file_wordsize;
-  int     dim_str_name;
-  int     int64_status = 0;
-  int     nc_mode      = 0;
+  int     exoid  = -1;
+  int     status = 0, stat_att = 0, stat_dim = 0;
+  nc_type att_type      = NC_NAT;
+  size_t  att_len       = 0;
+  int     old_fill      = 0;
+  int     file_wordsize = 0;
+  int     dim_str_name  = 0;
+  int     int64_status  = 0;
+  int     nc_mode       = 0;
 
   char errmsg[MAX_ERR_LENGTH];
 
   EX_FUNC_ENTER();
+  *version = 0.0f;
 
   /* set error handling mode to no messages, non-fatal errors */
   ex_opts(exoptval); /* call required to set ncopts first time through */
diff --git a/packages/seacas/libraries/exodus/src/ex_open_par.c b/packages/seacas/libraries/exodus/src/ex_open_par.c
index bc5a9886f3af..b2faa22c2948 100644
--- a/packages/seacas/libraries/exodus/src/ex_open_par.c
+++ b/packages/seacas/libraries/exodus/src/ex_open_par.c
@@ -147,18 +147,18 @@ struct ncvar /* variable */
 int ex_open_par_int(const char *path, int mode, int *comp_ws, int *io_ws, float *version,
                     MPI_Comm comm, MPI_Info info, int run_version)
 {
-  int     exoid;
-  int     status, stat_att, stat_dim;
-  nc_type att_type = NC_NAT;
-  size_t  att_len  = 0;
-  int     nc_mode  = 0;
-  int     old_fill;
-  int     file_wordsize;
-  int     dim_str_name;
-  int     int64_status = 0;
-  int     is_hdf5      = 0;
-  int     is_pnetcdf   = 0;
-  int     in_redef     = 0;
+  int     exoid  = -1;
+  int     status = 0, stat_att = 0, stat_dim = 0;
+  nc_type att_type      = NC_NAT;
+  size_t  att_len       = 0;
+  int     nc_mode       = 0;
+  int     old_fill      = 0;
+  int     file_wordsize = 0;
+  int     dim_str_name  = 0;
+  int     int64_status  = 0;
+  int     is_hdf5       = 0;
+  int     is_pnetcdf    = 0;
+  int     in_redef      = 0;
 
   char errmsg[MAX_ERR_LENGTH];
 
diff --git a/packages/seacas/libraries/exodus/src/ex_put_time.c b/packages/seacas/libraries/exodus/src/ex_put_time.c
index da58bde0ad86..64d5e8ae18f0 100644
--- a/packages/seacas/libraries/exodus/src/ex_put_time.c
+++ b/packages/seacas/libraries/exodus/src/ex_put_time.c
@@ -85,8 +85,6 @@ int ex_put_time(int exoid, int time_step, const void *time_value)
 
   EX_FUNC_ENTER();
 
-  ex__check_valid_file_id(exoid, __func__);
-
   file = ex__find_file_item(exoid);
   if (!file) {
     snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unknown file id %d.", exoid);
diff --git a/packages/seacas/libraries/exodus/src/ex_utils.c b/packages/seacas/libraries/exodus/src/ex_utils.c
index 5ec076a493a5..d094758394ff 100644
--- a/packages/seacas/libraries/exodus/src/ex_utils.c
+++ b/packages/seacas/libraries/exodus/src/ex_utils.c
@@ -2035,7 +2035,7 @@ int ex__populate_header(int exoid, const char *path, int my_mode, int is_paralle
   char  errmsg[MAX_ERR_LENGTH];
   int   int64_status = my_mode & (EX_ALL_INT64_DB | EX_ALL_INT64_API);
 
-  int format;
+  int format = 0;
   int mode;
 
   /* turn off automatic filling of netCDF variables */
diff --git a/packages/seacas/libraries/exodus/test/testrd.c b/packages/seacas/libraries/exodus/test/testrd.c
index 59c20ffc95cd..02b3c52a5934 100644
--- a/packages/seacas/libraries/exodus/test/testrd.c
+++ b/packages/seacas/libraries/exodus/test/testrd.c
@@ -1146,9 +1146,9 @@ int main(int argc, char **argv)
 
       free(var_values);
     }
-    free(num_elem_per_set);
     free(ids);
   }
+  free(num_elem_per_set);
 
   /* read a nodeset variable at one time step */
 
diff --git a/packages/seacas/libraries/exodus/test/testwt-oned.c b/packages/seacas/libraries/exodus/test/testwt-oned.c
index 8acf0b4dc97d..7270adde27a9 100644
--- a/packages/seacas/libraries/exodus/test/testwt-oned.c
+++ b/packages/seacas/libraries/exodus/test/testwt-oned.c
@@ -178,6 +178,7 @@ int main(int argc, char **argv)
   /* Circle */
   connect[0] = 5;
   EXCHECK(ex_put_conn(exoid, EX_ELEM_BLOCK, ebids[2], connect, NULL, NULL));
+  free(connect);
 
   /* write element block attributes */
   for (i = 0; i < num_elem; i++) {
diff --git a/packages/seacas/libraries/ioss/src/CMakeLists.txt b/packages/seacas/libraries/ioss/src/CMakeLists.txt
index 157ce121d42d..db7749853c01 100644
--- a/packages/seacas/libraries/ioss/src/CMakeLists.txt
+++ b/packages/seacas/libraries/ioss/src/CMakeLists.txt
@@ -112,14 +112,14 @@ IF (TPL_ENABLE_ADIOS2)
   ADD_SUBDIRECTORY(adios)
 ENDIF()
 
+IF (NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+ADD_SUBDIRECTORY(visualization)
+ENDIF()
 ADD_SUBDIRECTORY(generated)
 ADD_SUBDIRECTORY(gen_struc)
 ADD_SUBDIRECTORY(heartbeat)
 ADD_SUBDIRECTORY(transform)
 ADD_SUBDIRECTORY(init)
 ADD_SUBDIRECTORY(main)
-IF (NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
-ADD_SUBDIRECTORY(visualization)
-ENDIF()
 
 TRIBITS_ADD_TEST_DIRECTORIES(utest)
diff --git a/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.C b/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.C
index 11f66137debf..8c681356b77d 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.C
+++ b/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.C
@@ -54,15 +54,14 @@
 #define USE_MURMUR
 //#define USE_RANDOM
 
+#define DO_TIMING 1
+
 #if defined(__GNUC__) && __GNUC__ >= 7 && !__INTEL_COMPILER
 #define FALL_THROUGH [[gnu::fallthrough]]
 #else
 #define FALL_THROUGH ((void)0)
 #endif /* __GNUC__ >= 7 */
 
-size_t Ioss::FaceGenerator::fequal = 0;
-size_t Ioss::FaceGenerator::secondary = 0;
-
 namespace {
   template <typename T> void generate_index(std::vector<T> &index)
   {
@@ -207,7 +206,7 @@ namespace {
         if (face.elementCount_ == 1) {
           // On 'boundary' -- try to determine whether on processor or exterior
           // boundary
-          int                face_node_count = 0;
+          int face_node_count = 0;
           for (auto &gnode : face.connectivity_) {
             if (gnode > 0) {
               auto node = region.get_database()->node_global_to_local(gnode, true) - 1;
@@ -221,11 +220,11 @@ namespace {
               }
             }
           }
-	  for (size_t i=0; i < proc_count; i++) {
-	    if (shared_nodes[i] == face_node_count) {
+          for (size_t i = 0; i < proc_count; i++) {
+            if (shared_nodes[i] == face_node_count) {
               potential_count[i]++;
             }
-	    shared_nodes[i] = 0; // Reset for next trip through face.connectivity_ loop
+            shared_nodes[i] = 0; // Reset for next trip through face.connectivity_ loop
           }
         }
       }
@@ -240,7 +239,7 @@ namespace {
         if (face.elementCount_ == 1) {
           // On 'boundary' -- try to determine whether on processor or exterior
           // boundary
-          int                face_node_count = 0;
+          int face_node_count = 0;
           for (auto &gnode : face.connectivity_) {
             if (gnode > 0) {
               auto node = region.get_database()->node_global_to_local(gnode, true) - 1;
@@ -254,8 +253,8 @@ namespace {
               }
             }
           }
-	  for (size_t i=0; i < proc_count; i++) {
-	    if (shared_nodes[i] == face_node_count) {
+          for (size_t i = 0; i < proc_count; i++) {
+            if (shared_nodes[i] == face_node_count) {
               size_t offset                   = potential_offset[i];
               potential_faces[6 * offset + 0] = face.hashId_;
               potential_faces[6 * offset + 1] = face.connectivity_[0];
@@ -266,7 +265,7 @@ namespace {
               assert(face.elementCount_ == 1);
               potential_offset[i]++;
             }
-	    shared_nodes[i] = 0; // Reset for next trip through face.connectivity_ loop
+            shared_nodes[i] = 0; // Reset for next trip through face.connectivity_ loop
           }
         }
       }
@@ -356,13 +355,18 @@ namespace Ioss {
     nb->get_field_data("ids", ids);
 
     // Convert ids into hashed-ids
-    //    auto                starth = std::chrono::high_resolution_clock::now();
+#if DO_TIMING
+    auto starth = std::chrono::high_resolution_clock::now();
+#endif
     std::vector<size_t> hash_ids;
     hash_ids.reserve(ids.size());
     for (auto id : ids) {
       hash_ids.push_back(id_hash(id));
     }
-    //    auto endh = std::chrono::high_resolution_clock::now();
+
+#if DO_TIMING
+    auto endh = std::chrono::high_resolution_clock::now();
+#endif
 
     const Ioss::ElementBlockContainer &ebs = region_.get_element_blocks();
     for (auto eb : ebs) {
@@ -373,15 +377,16 @@ namespace Ioss {
       internal_generate_faces(eb, faces_[name], ids, hash_ids, (INT)0);
     }
 
-    //    auto   endf       = std::chrono::high_resolution_clock::now();
+#if DO_TIMING
+    auto endf = std::chrono::high_resolution_clock::now();
+#endif
     size_t face_count = 0;
     for (auto eb : ebs) {
       resolve_parallel_faces(region_, faces_[eb->name()], hash_ids, (INT)0);
       face_count += faces_[eb->name()].size();
     }
-    //    auto endp = std::chrono::high_resolution_clock::now();
-
-#if 0
+#if DO_TIMING
+    auto endp  = std::chrono::high_resolution_clock::now();
     auto diffh = endh - starth;
     auto difff = endf - endh;
     fmt::print("Node ID hash time:   \t{} ms\t{} nodes/second\n"
@@ -413,13 +418,17 @@ namespace Ioss {
     nb->get_field_data("ids", ids);
 
     // Convert ids into hashed-ids
-    //    auto                starth = std::chrono::high_resolution_clock::now();
+#if DO_TIMING
+    auto starth = std::chrono::high_resolution_clock::now();
+#endif
     std::vector<size_t> hash_ids;
     hash_ids.reserve(ids.size());
     for (auto id : ids) {
       hash_ids.push_back(id_hash(id));
     }
-    //    auto endh = std::chrono::high_resolution_clock::now();
+#if DO_TIMING
+    auto endh = std::chrono::high_resolution_clock::now();
+#endif
 
     auto & my_faces = faces_["ALL"];
     size_t numel    = region_.get_property("element_count").get_int();
@@ -431,12 +440,13 @@ namespace Ioss {
       internal_generate_faces(eb, my_faces, ids, hash_ids, (INT)0);
     }
 
-    //    auto endf = std::chrono::high_resolution_clock::now();
+#if DO_TIMING
+    auto endf = std::chrono::high_resolution_clock::now();
+#endif
     resolve_parallel_faces(region_, my_faces, hash_ids, (INT)0);
 
-    //    auto endp = std::chrono::high_resolution_clock::now();
-
-#if 0
+#if DO_TIMING
+    auto endp  = std::chrono::high_resolution_clock::now();
     auto diffh = endh - starth;
     auto difff = endf - endh;
     fmt::print("Node ID hash time:   \t{} ms\t{} nodes/second\n"
diff --git a/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h b/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h
index 814bee2046a5..a52320bfccb1 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h
+++ b/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h
@@ -49,7 +49,6 @@
 
 #include <utility>
 
-
 namespace Ioss {
   class Region;
 
@@ -66,6 +65,7 @@ namespace Ioss {
     }
 
     size_t hashId_{0};
+
     // NOTE: Not used at all by `Face` or `FaceGenerator` class, but are used by
     // skinner to give a consistent element id in cases where there
     // is a hash collision (face.id).
@@ -79,9 +79,8 @@ namespace Ioss {
     // you could recover element_id and local_face and then set up
     // parallel communication maps.  May need to save the proc it is
     // shared with also (which is available in git history)
-
-    mutable size_t element[2]{};
-    mutable int    elementCount_{0}; // Should be max of 2 solid elements...
+    mutable size_t        element[2]{};
+    mutable int           elementCount_{0}; // Should be max of 2 solid elements...
     std::array<size_t, 4> connectivity_{};
   };
 
@@ -90,25 +89,7 @@ namespace Ioss {
     size_t operator()(const Face &face) const { return face.hashId_; }
   };
 
-  struct FaceEqual
-  {
-    bool operator()(const Face &left, const Face &right) const
-    {
-      if (left.hashId_ != right.hashId_) {
-        return false;
-      }
-      // Hash (hashId_) is equal
-      // Check whether same vertices (can be in different order)
-      for (auto lvert : left.connectivity_) {
-        if (std::find(right.connectivity_.cbegin(), right.connectivity_.cend(), lvert) ==
-            right.connectivity_.cend()) {
-          // Not found, therefore not the same.
-          return false;
-        }
-      }
-      return true;
-    }
-  };
+  struct FaceEqual;
 
 #if defined USE_STD
   using FaceUnorderedSet = std::unordered_set<Face, FaceHash, FaceEqual>;
@@ -123,17 +104,11 @@ namespace Ioss {
   {
   public:
     explicit FaceGenerator(Ioss::Region &region);
-    ~FaceGenerator()
-      {
-	std::cout << "FaceEqual Calls: " << fequal << "\t" << secondary << "\n";
-      }
+    ~FaceGenerator() = default;
 
     template <typename INT> void generate_faces(INT /*dummy*/, bool block_by_block = false);
     FaceUnorderedSet &           faces(const std::string &name = "ALL") { return faces_[name]; }
 
-    static size_t fequal;
-    static size_t secondary;
-
   private:
     template <typename INT> void            generate_block_faces(INT /*dummy*/);
     template <typename INT> void            generate_model_faces(INT /*dummy*/);
@@ -141,6 +116,30 @@ namespace Ioss {
     std::map<std::string, FaceUnorderedSet> faces_;
   };
 
+  struct FaceEqual
+  {
+    bool operator()(const Face &left, const Face &right) const
+    {
+      if (left.hashId_ != right.hashId_) {
+        return false;
+      }
+      // Hash (hashId_) is equal
+      // Check whether same vertices (can be in different order)
+      // Most (All?) of the time, there are no hashId_ collisions, so this test will not
+      // find a difference and the function will return 'true'
+      // However, for some reason, removing this check does not change the execution time
+      // appreiciably...
+      for (auto lvert : left.connectivity_) {
+        if (std::find(right.connectivity_.cbegin(), right.connectivity_.cend(), lvert) ==
+            right.connectivity_.cend()) {
+          // Not found, therefore not the same.
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+
 } // namespace Ioss
 
 #endif
diff --git a/packages/seacas/libraries/ioss/src/Ioss_GroupingEntity.h b/packages/seacas/libraries/ioss/src/Ioss_GroupingEntity.h
index 44545451e030..543a9f9bc1f5 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_GroupingEntity.h
+++ b/packages/seacas/libraries/ioss/src/Ioss_GroupingEntity.h
@@ -467,7 +467,7 @@ int64_t Ioss::GroupingEntity::get_field_data(const std::string &field_name,
 
   data.resize(field.raw_count() * field.raw_storage()->component_count());
   size_t data_size = data.size() * sizeof(T);
-  auto   retval    = internal_get_field_data(field, TOPTR(data), data_size);
+  auto retval    = internal_get_field_data(field, TOPTR(data), data_size);
 
   // At this point, transform the field if specified...
   if (retval >= 0) {
diff --git a/packages/seacas/libraries/ioss/src/Ioss_IOFactory.C b/packages/seacas/libraries/ioss/src/Ioss_IOFactory.C
index 8f2753a151ca..f63dea1da9b1 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_IOFactory.C
+++ b/packages/seacas/libraries/ioss/src/Ioss_IOFactory.C
@@ -34,7 +34,8 @@
 #include <Ioss_IOFactory.h>
 #include <Ioss_ParallelUtils.h>
 #include <Ioss_Utils.h> // for IOSS_ERROR
-#include <cstddef>      // for nullptr
+#include <Ioss_Version.h>
+#include <cstddef> // for nullptr
 #include <fmt/ostream.h>
 #include <map>     // for _Rb_tree_iterator, etc
 #include <ostream> // for basic_ostream, etc
@@ -105,11 +106,8 @@ Ioss::DatabaseIO *Ioss::IOFactory::create(const std::string &type, const std::st
       fmt::print(errmsg, "ERROR: The database type '{}' is not supported.\n", type);
       Ioss::NameList db_types;
       describe__(registry(), &db_types);
-      fmt::print(errmsg, "\nSupported database types:\n\t");
-      for (Ioss::NameList::const_iterator IF = db_types.begin(); IF != db_types.end(); ++IF) {
-        fmt::print(errmsg, "{} ", *IF);
-      }
-      fmt::print(errmsg, "\n\n");
+      fmt::print(errmsg, "\nSupported database types:\n\t{}\n\n",
+                 fmt::join(db_types.begin(), db_types.end(), " "));
       IOSS_ERROR(errmsg);
     }
   }
@@ -136,9 +134,10 @@ int Ioss::IOFactory::describe(NameList *names)
 
 void Ioss::IOFactory::show_configuration()
 {
+  fmt::print(stderr, "\nIOSS Library Version '{}'\n\n", Ioss::Version());
   NameList db_types;
   describe(&db_types);
-  fmt::print(stderr, "\nSupported database types:\n\t");
+  fmt::print(stderr, "Supported database types:\n\t");
   for (const auto &db_type : db_types) {
     fmt::print(stderr, "{} ", db_type);
   }
diff --git a/packages/seacas/libraries/ioss/src/Ioss_Utils.C b/packages/seacas/libraries/ioss/src/Ioss_Utils.C
index f5a11f4c3151..f7595b40d6e9 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_Utils.C
+++ b/packages/seacas/libraries/ioss/src/Ioss_Utils.C
@@ -444,7 +444,7 @@ std::string Ioss::Utils::fixup_type(const std::string &base, int nodes_per_eleme
     }
   }
 
-  if (std::strncmp(type.c_str(), "super", 5) == 0) {
+  if (Ioss::Utils::substr_equal("super", type)) {
     // A super element can have a varying number of nodes.  Create
     // an IO element type for this super element just so the IO
     // system can read a mesh containing super elements.  This
@@ -553,9 +553,7 @@ namespace {
     // and see if it defines a valid type...
     std::vector<Ioss::Suffix> suffices;
 
-    char suffix[2];
-    suffix[0] = suffix_separator;
-    suffix[1] = 0;
+    char suffix[2] = {suffix_separator, '\0'};
 
     for (int which_name : which_names) {
       std::vector<std::string> tokens     = Ioss::tokenize(names[which_name], suffix);
@@ -1166,18 +1164,16 @@ void Ioss::Utils::input_file(const std::string &file_name, std::vector<std::stri
   }
 }
 
-int Ioss::Utils::case_strcmp(const std::string &s1, const std::string &s2)
+bool Ioss::Utils::str_equal(const std::string &s1, const std::string &s2)
 {
-  const char *c1 = s1.c_str();
-  const char *c2 = s2.c_str();
-  for (;; c1++, c2++) {
-    if (std::tolower(*c1) != std::tolower(*c2)) {
-      return (std::tolower(*c1) - std::tolower(*c2));
-    }
-    if (*c1 == '\0') {
-      return 0;
-    }
-  }
+  return (s1.size() == s2.size()) &&
+         std::equal(s1.begin(), s1.end(), s2.begin(),
+                    [](char a, char b) { return std::tolower(a) == std::tolower(b); });
+}
+
+bool Ioss::Utils::substr_equal(const std::string &prefix, const std::string &str)
+{
+  return (str.size() >= prefix.size()) && str_equal(prefix, str.substr(0, prefix.size()));
 }
 
 std::string Ioss::Utils::uppercase(std::string name)
@@ -2217,8 +2213,7 @@ namespace {
         max_field_size = field.get_size();
       }
       if (field_name != "ids" && !oge->field_exists(field_name) &&
-          (prefix.empty() ||
-           std::strncmp(prefix.c_str(), field_name.c_str(), prefix.length()) == 0)) {
+          Ioss::Utils::substr_equal(prefix, field_name)) {
         // If the field does not already exist, add it to the output node block
         oge->field_add(field);
       }
@@ -2252,8 +2247,7 @@ namespace {
       if (field_name == "ids") {
         continue;
       }
-      if ((prefix.empty() ||
-           std::strncmp(prefix.c_str(), field_name.c_str(), prefix.length()) == 0)) {
+      if (Ioss::Utils::substr_equal(prefix, field_name)) {
         assert(oge->field_exists(field_name));
         transfer_field_data_internal(ige, oge, pool, field_name, options);
       }
diff --git a/packages/seacas/libraries/ioss/src/Ioss_Utils.h b/packages/seacas/libraries/ioss/src/Ioss_Utils.h
index 1bc8dfb36b0f..cb3bfa004f4c 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_Utils.h
+++ b/packages/seacas/libraries/ioss/src/Ioss_Utils.h
@@ -360,9 +360,17 @@ namespace Ioss {
      *
      *  \param[in] s1 First string
      *  \param[in] s2 Second string
-     *  \returns 0 if strings are equal, nonzero otherwise.
+     *  \returns `true` if strings are equal
      */
-    static int case_strcmp(const std::string &s1, const std::string &s2);
+    static bool str_equal(const std::string &s1, const std::string &s2);
+
+    /** \brief Case-insensitive substring comparison.
+     *
+     *  \param[in] prefix
+     *  \param[in] str
+     *  \returns `true` if `str` begins with `prefix` or `prefix` is empty
+     */
+    static bool substr_equal(const std::string &prefix, const std::string &str);
 
     /** \brief Get a string containing `uname` output.
      *
diff --git a/packages/seacas/libraries/ioss/src/Ioss_VariableType.C b/packages/seacas/libraries/ioss/src/Ioss_VariableType.C
index bcd2fb06be95..a76b305d6557 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_VariableType.C
+++ b/packages/seacas/libraries/ioss/src/Ioss_VariableType.C
@@ -219,7 +219,7 @@ namespace Ioss {
       size_t width = Ioss::Utils::number_width(size);
       for (size_t i = 0; i < size; i++) {
         std::string digits = fmt::format("{:0{}}", i + 1, width);
-        if (std::strcmp(&suffices[i].m_data[0], digits.c_str()) != 0) {
+        if (!Ioss::Utils::str_equal(&suffices[i].m_data[0], digits)) {
           match = false;
           break;
         }
diff --git a/packages/seacas/libraries/ioss/src/Ioss_Version.h b/packages/seacas/libraries/ioss/src/Ioss_Version.h
new file mode 100644
index 000000000000..956acfd0d1ba
--- /dev/null
+++ b/packages/seacas/libraries/ioss/src/Ioss_Version.h
@@ -0,0 +1,38 @@
+// Copyright(C) 1999-2017 National Technology & Engineering Solutions
+// of Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
+// NTESS, the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//
+//     * Neither the name of NTESS nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef IOSS_VERSION_H
+#define IOSS_VERSION_H
+namespace Ioss {
+  inline const char *Version() { return "2019-10-30"; }
+} // namespace Ioss
+#endif
diff --git a/packages/seacas/libraries/ioss/src/catch.hpp b/packages/seacas/libraries/ioss/src/catch.hpp
index 4c2c638fffb6..7cbd8f7cf9a2 100644
--- a/packages/seacas/libraries/ioss/src/catch.hpp
+++ b/packages/seacas/libraries/ioss/src/catch.hpp
@@ -1,6 +1,6 @@
 /*
- *  Catch v2.9.2
- *  Generated: 2019-08-08 13:35:12.279703
+ *  Catch v2.10.2
+ *  Generated: 2019-10-24 17:49:11.459934
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
  *  Copyright (c) 2019 Two Blue Cubes Ltd. All rights reserved.
@@ -12,88 +12,88 @@
 #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
 // start catch.hpp
 
-
 #define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 9
+#define CATCH_VERSION_MINOR 10
 #define CATCH_VERSION_PATCH 2
 
 #ifdef __clang__
-#    pragma clang system_header
+#pragma clang system_header
 #elif defined __GNUC__
-#    pragma GCC system_header
+#pragma GCC   system_header
 #endif
 
 // start catch_suppress_warnings.h
 
 #ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       pragma warning(push)
-#       pragma warning(disable: 161 1682)
-#   else // __ICC
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wswitch-enum"
-#       pragma clang diagnostic ignored "-Wcovered-switch-default"
-#    endif
-#elif defined __GNUC__
-     // Because REQUIREs trigger GCC's -Wparentheses, and because still
-     // supported version of g++ have only buggy support for _Pragmas,
-     // Wparentheses have to be suppressed globally.
-#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wpadded"
+#ifdef __ICC // icpc defines the __clang__ macro
+#pragma warning(push)
+#pragma warning(disable : 161 1682)
+#else // __ICC
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#endif
+#elif defined          __GNUC__
+// Because REQUIREs trigger GCC's -Wparentheses, and because still
+// supported version of g++ have only buggy support for _Pragmas,
+// Wparentheses have to be suppressed globally.
+#pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wpadded"
 #endif
 // end catch_suppress_warnings.h
 #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
+#define CATCH_IMPL
+#define CATCH_CONFIG_ALL_PARTS
 #endif
 
 // In the impl file, we want to have access to all parts of the headers
 // Can also be used to sanely support PCHs
 #if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
+#define CATCH_CONFIG_EXTERNAL_INTERFACES
+#if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#undef CATCH_CONFIG_DISABLE_MATCHERS
+#endif
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
 #endif
 
 #if !defined(CATCH_CONFIG_IMPL_ONLY)
 // start catch_platform.h
 
 #ifdef __APPLE__
-# include <TargetConditionals.h>
-# if TARGET_OS_OSX == 1
-#  define CATCH_PLATFORM_MAC
-# elif TARGET_OS_IPHONE == 1
-#  define CATCH_PLATFORM_IPHONE
-# endif
+#include <TargetConditionals.h>
+#if TARGET_OS_OSX == 1
+#define CATCH_PLATFORM_MAC
+#elif TARGET_OS_IPHONE == 1
+#define CATCH_PLATFORM_IPHONE
+#endif
 
 #elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
+#define CATCH_PLATFORM_LINUX
 
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) ||              \
+    defined(__MINGW32__)
+#define CATCH_PLATFORM_WINDOWS
 #endif
 
 // end catch_platform.h
 
 #ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
+#ifndef CLARA_CONFIG_MAIN
+#define CLARA_CONFIG_MAIN_NOT_DEFINED
+#define CLARA_CONFIG_MAIN
+#endif
 #endif
 
 // start catch_user_interfaces.h
 
 namespace Catch {
-    unsigned int rngSeed();
+  unsigned int rngSeed();
 }
 
 // end catch_user_interfaces.h
@@ -122,82 +122,79 @@ namespace Catch {
 
 #ifdef __cplusplus
 
-#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#    define CATCH_CPP14_OR_GREATER
-#  endif
+#if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#define CATCH_CPP14_OR_GREATER
+#endif
 
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
+#if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#define CATCH_CPP17_OR_GREATER
+#endif
 
 #endif
 
 #if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #endif
 
 #ifdef __clang__
 
-#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
+#define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                   \
+  _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wexit-time-destructors\"") \
+      _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"")
+#define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS _Pragma("clang diagnostic pop")
+
+#define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS                                               \
+  _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wparentheses\"")
+#define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS _Pragma("clang diagnostic pop")
 
+#define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS                                                    \
+  _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wunused-variable\"")
+#define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS _Pragma("clang diagnostic pop")
+
+#define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                                             \
+  _Pragma("clang diagnostic push")                                                                 \
+      _Pragma("clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"")
+#define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS _Pragma("clang diagnostic pop")
+
+#define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                           \
+  _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wunused-template\"")
+#define CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS _Pragma("clang diagnostic pop")
 #endif // __clang__
 
 ////////////////////////////////////////////////////////////////////////////////
 // Assume that non-Windows platforms support posix signals by default
 #if !defined(CATCH_PLATFORM_WINDOWS)
-    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // We know some environments not to support full POSIX signals
 #if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
-    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
 #endif
 
 #ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
+#define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#define CATCH_CONFIG_COLOUR_NONE
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Android somehow still does not support std::to_string
 #if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Not all Windows environments support SEH properly
 #if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // PS4
 #if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -206,62 +203,62 @@ namespace Catch {
 
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
+#define _BSD_SOURCE
 // some versions of cygwin (most) do not support std::to_string. Use the libstd check.
 // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+#if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) &&                                     \
+      !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
 
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
 
-# endif
+#endif
 #endif // __CYGWIN__
 
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
 #ifdef _MSC_VER
 
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
+#if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
 
 // Universal Windows platform does not support SEH
 // Or console colours (or console at all...)
-#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#    define CATCH_CONFIG_COLOUR_NONE
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define CATCH_CONFIG_COLOUR_NONE
+#else
+#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#endif
 
 // MSVC traditional preprocessor needs some workaround for __VA_ARGS__
 // _MSVC_TRADITIONAL == 0 means new conformant preprocessor
 // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#    define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#  endif
+#if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
 #endif // _MSC_VER
 
 #if defined(_REENTRANT) || defined(_MSC_VER)
 // Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#define CATCH_INTERNAL_CONFIG_USE_ASYNC
 #endif // _MSC_VER
 
 ////////////////////////////////////////////////////////////////////////////////
 // Check if we are compiled with -fno-exceptions or equivalent
 #if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // DJGPP
 #ifdef __DJGPP__
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#define CATCH_INTERNAL_CONFIG_NO_WCHAR
 #endif // __DJGPP__
 
 ////////////////////////////////////////////////////////////////////////////////
 // Embarcadero C++Build
 #if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -271,8 +268,8 @@ namespace Catch {
 // handled by it.
 // Otherwise all supported compilers support COUNTER macro,
 // but user still might want to turn it off
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
+#if (!defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L)
+#define CATCH_INTERNAL_CONFIG_COUNTER
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -281,129 +278,164 @@ namespace Catch {
 // This means that it is detected as Windows, but does not provide
 // the same set of capabilities as real Windows does.
 #if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
+#define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#define CATCH_INTERNAL_CONFIG_NO_ASYNC
+#define CATCH_CONFIG_COLOUR_NONE
 #endif
 
-////////////////////////////////////////////////////////////////////////////////
-// Check if string_view is available and usable
-// The check is split apart to work around v140 (VS2015) preprocessor issue...
+#if defined(__UCLIBC__)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
 #if defined(__has_include)
+// Check if string_view is available and usable
 #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-#    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-#endif
+#define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
 #endif
 
-////////////////////////////////////////////////////////////////////////////////
 // Check if optional is available and usable
-#if defined(__has_include)
-#  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-#    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-#  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // __has_include
+#if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+#endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
 
-////////////////////////////////////////////////////////////////////////////////
 // Check if byte is available and usable
-#if defined(__has_include)
-#  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-#    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-#  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // __has_include
+#if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+#define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+#endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
 
-////////////////////////////////////////////////////////////////////////////////
 // Check if variant is available and usable
-#if defined(__has_include)
-#  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#    if defined(__clang__) && (__clang_major__ < 8)
-       // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-       // fix should be in clang 8, workaround in libstdc++ 8.2
-#      include <ciso646>
-#      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-#        define CATCH_CONFIG_NO_CPP17_VARIANT
-#      else
-#        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-#      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-#    else
-#      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-#    endif // defined(__clang__) && (__clang_major__ < 8)
-#  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // __has_include
-
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
-#   define CATCH_CONFIG_COUNTER
+#if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#if defined(__clang__) && (__clang_major__ < 8)
+// work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+// fix should be in clang 8, workaround in libstdc++ 8.2
+#include <ciso646>
+#if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#define CATCH_CONFIG_NO_CPP17_VARIANT
+#else
+#define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#else
+#define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#endif // defined(__clang__) && (__clang_major__ < 8)
+#endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) &&                 \
+    !defined(CATCH_CONFIG_COUNTER)
+#define CATCH_CONFIG_COUNTER
 #endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) &&         \
+    !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+#define CATCH_CONFIG_WINDOWS_SEH
 #endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by
+// default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) &&                                                \
+    !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && \
+    !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#define CATCH_CONFIG_POSIX_SIGNALS
 #endif
-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
-#   define CATCH_CONFIG_WCHAR
+// This is set by default, because we assume that compilers with no wchar_t support are just rare
+// exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) &&                 \
+    !defined(CATCH_CONFIG_WCHAR)
+#define CATCH_CONFIG_WCHAR
 #endif
 
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) &&                                          \
+    !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#define CATCH_CONFIG_CPP11_TO_STRING
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) &&   \
+    !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#define CATCH_CONFIG_CPP17_OPTIONAL
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) &&                                    \
+    !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) &&                                         \
+    !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) &&                                            \
+    !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#define CATCH_CONFIG_CPP17_STRING_VIEW
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) &&     \
+    !defined(CATCH_CONFIG_CPP17_VARIANT)
+#define CATCH_CONFIG_CPP17_VARIANT
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) &&           \
+    !defined(CATCH_CONFIG_CPP17_BYTE)
+#define CATCH_CONFIG_CPP17_BYTE
 #endif
 
 #if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) &&                                                  \
+    !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) &&     \
+    !defined(CATCH_CONFIG_NEW_CAPTURE)
+#define CATCH_CONFIG_NEW_CAPTURE
 #endif
 
 #if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) &&   \
+    !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) &&        \
+    !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#define CATCH_CONFIG_USE_ASYNC
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) &&                                             \
+    !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#define CATCH_CONFIG_ANDROID_LOGWRITE
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) &&                                             \
+    !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#define CATCH_CONFIG_GLOBAL_NEXTAFTER
 #endif
 
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
+#define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+#define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
+#define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS
+#define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#undef CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#undef CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#define CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS
 #endif
 
 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
@@ -416,102 +448,107 @@ namespace Catch {
 #define CATCH_CATCH_ANON(type) catch (type)
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) &&                                \
+    !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) &&                                     \
+    !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
 #define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #endif
 
 // end catch_compiler_capabilities.h
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2(name, line) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE(name, line) INTERNAL_CATCH_UNIQUE_NAME_LINE2(name, line)
 #ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#define INTERNAL_CATCH_UNIQUE_NAME(name) INTERNAL_CATCH_UNIQUE_NAME_LINE(name, __COUNTER__)
 #else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#define INTERNAL_CATCH_UNIQUE_NAME(name) INTERNAL_CATCH_UNIQUE_NAME_LINE(name, __LINE__)
 #endif
 
+#include <cstdint>
 #include <iosfwd>
 #include <string>
-#include <cstdint>
 
 // We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+struct Catch_global_namespace_dummy
+{
+};
+std::ostream &operator<<(std::ostream &, Catch_global_namespace_dummy);
 
 namespace Catch {
 
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-        :   file( _file ),
-            line( _line )
-        {}
-
-        SourceLineInfo( SourceLineInfo const& other )            = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
-        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
-        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
-
-        bool empty() const noexcept;
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // Bring in operator<< from global namespace into Catch namespace
-    // This is necessary because the overload of operator<< above makes
-    // lookup stop at namespace Catch
-    using ::operator<<;
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
+  struct CaseSensitive
+  {
+    enum Choice { Yes, No };
+  };
+
+  class NonCopyable
+  {
+    NonCopyable(NonCopyable const &) = delete;
+    NonCopyable(NonCopyable &&)      = delete;
+    NonCopyable &operator=(NonCopyable const &) = delete;
+    NonCopyable &operator=(NonCopyable &&) = delete;
+
+  protected:
+    NonCopyable();
+    virtual ~NonCopyable();
+  };
+
+  struct SourceLineInfo
+  {
+
+    SourceLineInfo() = delete;
+    SourceLineInfo(char const *_file, std::size_t _line) noexcept : file(_file), line(_line) {}
+
+    SourceLineInfo(SourceLineInfo const &other) = default;
+    SourceLineInfo &operator=(SourceLineInfo const &) = default;
+    SourceLineInfo(SourceLineInfo &&) noexcept        = default;
+    SourceLineInfo &operator=(SourceLineInfo &&) noexcept = default;
+
+    bool empty() const noexcept { return file[0] == '\0'; }
+    bool operator==(SourceLineInfo const &other) const noexcept;
+    bool operator<(SourceLineInfo const &other) const noexcept;
+
+    char const *file;
+    std::size_t line;
+  };
+
+  std::ostream &operator<<(std::ostream &os, SourceLineInfo const &info);
+
+  // Bring in operator<< from global namespace into Catch namespace
+  // This is necessary because the overload of operator<< above makes
+  // lookup stop at namespace Catch
+  using ::operator<<;
+
+  // Use this in variadic streaming macros to allow
+  //    >> +StreamEndStop
+  // as well as
+  //    >> stuff +StreamEndStop
+  struct StreamEndStop
+  {
+    std::string operator+() const;
+  };
+  template <typename T> T const &operator+(T const &value, StreamEndStop) { return value; }
+} // namespace Catch
 
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+#define CATCH_INTERNAL_LINEINFO                                                                    \
+  ::Catch::SourceLineInfo(__FILE__, static_cast<std::size_t>(__LINE__))
 
 // end catch_common.h
 namespace Catch {
 
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
+  struct RegistrarForTagAliases
+  {
+    RegistrarForTagAliases(char const *alias, char const *tag, SourceLineInfo const &lineInfo);
+  };
 
 } // end namespace Catch
 
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+#define CATCH_REGISTER_TAG_ALIAS(alias, spec)                                                      \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    Catch::RegistrarForTagAliases                                                                  \
+        INTERNAL_CATCH_UNIQUE_NAME(AutoRegisterTagAlias)(alias, spec, CATCH_INTERNAL_LINEINFO);    \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
 // end catch_tag_alias_autoregistrar.h
 // start catch_test_registry.h
@@ -522,203 +559,173 @@ namespace Catch {
 
 namespace Catch {
 
-    class TestSpec;
+  class TestSpec;
 
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
+  struct ITestInvoker
+  {
+    virtual void invoke() const = 0;
+    virtual ~ITestInvoker();
+  };
 
-    class TestCase;
-    struct IConfig;
+  class TestCase;
+  struct IConfig;
 
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
+  struct ITestCaseRegistry
+  {
+    virtual ~ITestCaseRegistry();
+    virtual std::vector<TestCase> const &getAllTests() const                            = 0;
+    virtual std::vector<TestCase> const &getAllTestsSorted(IConfig const &config) const = 0;
+  };
 
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+  bool isThrowSafe(TestCase const &testCase, IConfig const &config);
+  bool matchTest(TestCase const &testCase, TestSpec const &testSpec, IConfig const &config);
+  std::vector<TestCase>        filterTests(std::vector<TestCase> const &testCases,
+                                           TestSpec const &testSpec, IConfig const &config);
+  std::vector<TestCase> const &getAllTestCasesSorted(IConfig const &config);
 
-}
+} // namespace Catch
 
 // end catch_interfaces_testcase.h
 // start catch_stringref.h
 
+#include <cassert>
 #include <cstddef>
-#include <string>
 #include <iosfwd>
+#include <string>
 
 namespace Catch {
 
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated. c_str() must return a null terminated
-    /// string, however, and so the StringRef will internally take ownership
-    /// (taking a copy), if necessary. In theory this ownership is not externally
-    /// visible - but it does mean (substring) StringRefs should not be shared between
-    /// threads.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
+  /// A non-owning string class (similar to the forthcoming std::string_view)
+  /// Note that, because a StringRef may be a substring of another string,
+  /// it may not be null terminated. c_str() must return a null terminated
+  /// string, however, and so the StringRef will internally take ownership
+  /// (taking a copy), if necessary. In theory this ownership is not externally
+  /// visible - but it does mean (substring) StringRefs should not be shared between
+  /// threads.
+  class StringRef
+  {
+  public:
+    using size_type      = std::size_t;
+    using const_iterator = const char *;
 
-    private:
-        friend struct StringRefTestAccess;
+  private:
+    friend struct StringRefTestAccess;
 
-        char const* m_start;
-        size_type m_size;
+    char const *m_start;
+    size_type   m_size;
 
-        char* m_data = nullptr;
+    char *m_data = nullptr;
 
-        void takeOwnership();
+    void takeOwnership();
 
-        static constexpr char const* const s_empty = "";
+    static constexpr char const *const s_empty = "";
 
-    public: // construction/ assignment
-        StringRef() noexcept
-        :   StringRef( s_empty, 0 )
-        {}
+  public: // construction/ assignment
+    StringRef() noexcept : StringRef(s_empty, 0) {}
 
-        StringRef( StringRef const& other ) noexcept
-        :   m_start( other.m_start ),
-            m_size( other.m_size )
-        {}
+    StringRef(StringRef const &other) noexcept : m_start(other.m_start), m_size(other.m_size) {}
 
-        StringRef( StringRef&& other ) noexcept
-        :   m_start( other.m_start ),
-            m_size( other.m_size ),
-            m_data( other.m_data )
-        {
-            other.m_data = nullptr;
-        }
+    StringRef(StringRef &&other) noexcept
+        : m_start(other.m_start), m_size(other.m_size), m_data(other.m_data)
+    {
+      other.m_data = nullptr;
+    }
 
-        StringRef( char const* rawChars ) noexcept;
+    StringRef(char const *rawChars) noexcept;
 
-        StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
+    StringRef(char const *rawChars, size_type size) noexcept : m_start(rawChars), m_size(size) {}
 
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
+    StringRef(std::string const &stdString) noexcept
+        : m_start(stdString.c_str()), m_size(stdString.size())
+    {
+    }
 
-        ~StringRef() noexcept {
-            delete[] m_data;
-        }
+    ~StringRef() noexcept { delete[] m_data; }
 
-        auto operator = ( StringRef const &other ) noexcept -> StringRef& {
-            delete[] m_data;
-            m_data = nullptr;
-            m_start = other.m_start;
-            m_size = other.m_size;
-            return *this;
-        }
+    auto operator=(StringRef const &other) noexcept -> StringRef &
+    {
+      delete[] m_data;
+      m_data  = nullptr;
+      m_start = other.m_start;
+      m_size  = other.m_size;
+      return *this;
+    }
 
-        operator std::string() const;
+    explicit operator std::string() const { return std::string(m_start, m_size); }
 
-        void swap( StringRef& other ) noexcept;
+    void swap(StringRef &other) noexcept;
 
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != ( StringRef const& other ) const noexcept -> bool;
+  public: // operators
+    auto operator==(StringRef const &other) const noexcept -> bool;
+    auto operator!=(StringRef const &other) const noexcept -> bool;
 
-        auto operator[] ( size_type index ) const noexcept -> char;
+    auto operator[](size_type index) const noexcept -> char
+    {
+      assert(index < m_size);
+      return m_start[index];
+    }
 
-    public: // named queries
-        auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        auto size() const noexcept -> size_type {
-            return m_size;
-        }
+  public: // named queries
+    auto empty() const noexcept -> bool { return m_size == 0; }
+    auto size() const noexcept -> size_type { return m_size; }
 
-        auto numberOfCharacters() const noexcept -> size_type;
-        auto c_str() const -> char const*;
+    auto c_str() const -> char const *;
 
-    public: // substrings and searches
-        auto substr( size_type start, size_type size ) const noexcept -> StringRef;
+  public: // substrings and searches
+    auto substr(size_type start, size_type size) const noexcept -> StringRef;
 
-        // Returns the current start pointer.
-        // Note that the pointer can change when if the StringRef is a substring
-        auto currentData() const noexcept -> char const*;
+    // Returns the current start pointer.
+    // Note that the pointer can change when if the StringRef is a substring
+    auto currentData() const noexcept -> char const *;
 
-    private: // ownership queries - may not be consistent between calls
-        auto isOwned() const noexcept -> bool;
-        auto isSubstring() const noexcept -> bool;
-    };
+  public: // iterators
+    const_iterator begin() const { return m_start; }
+    const_iterator end() const { return m_start + m_size; }
 
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string;
-    auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string;
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string;
+  private: // ownership queries - may not be consistent between calls
+    auto isOwned() const noexcept -> bool;
+    auto isSubstring() const noexcept -> bool;
+  };
 
-    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+  auto operator+=(std::string &lhs, StringRef const &sr) -> std::string &;
+  auto operator<<(std::ostream &os, StringRef const &sr) -> std::ostream &;
 
-    inline auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
+  inline auto operator"" _sr(char const *rawChars, std::size_t size) noexcept -> StringRef
+  {
+    return StringRef(rawChars, size);
+  }
 
 } // namespace Catch
 
-inline auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
+inline auto operator"" _catch_sr(char const *rawChars, std::size_t size) noexcept
+    -> Catch::StringRef
+{
+  return Catch::StringRef(rawChars, size);
 }
 
 // end catch_stringref.h
-// start catch_type_traits.hpp
-
-
-#include <type_traits>
-
-namespace Catch{
-
-#ifdef CATCH_CPP17_OR_GREATER
-	template <typename...>
-	inline constexpr auto is_unique = std::true_type{};
-
-	template <typename T, typename... Rest>
-	inline constexpr auto is_unique<T, Rest...> = std::bool_constant<
-		(!std::is_same_v<T, Rest> && ...) && is_unique<Rest...>
-	>{};
-#else
-
-template <typename...>
-struct is_unique : std::true_type{};
-
-template <typename T0, typename T1, typename... Rest>
-struct is_unique<T0, T1, Rest...> : std::integral_constant
-<bool,
-     !std::is_same<T0, T1>::value
-     && is_unique<T0, Rest...>::value
-     && is_unique<T1, Rest...>::value
->{};
-
-#endif
-}
-
-// end catch_type_traits.hpp
 // start catch_preprocessor.hpp
 
-
 #define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL1(...)                                                                \
+  CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...)                                                                \
+  CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...)                                                                \
+  CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...)                                                                \
+  CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...)                                                                \
+  CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
 
 #ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
 // MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#define CATCH_RECURSION_LEVEL6(...)                                                                \
+  CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
 #else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)
 #endif
 
 #define CATCH_REC_END(...)
@@ -731,37 +738,51 @@ struct is_unique<T0, T1, Rest...> : std::integral_constant
 #define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
 #define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
 #define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER(CATCH_REC_NEXT0)(test, next, 0)
+#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...)                                                           \
+  , f(x) CATCH_DEFER(CATCH_REC_NEXT(peek, CATCH_REC_LIST1))(f, peek, __VA_ARGS__)
+#define CATCH_REC_LIST1(f, x, peek, ...)                                                           \
+  , f(x) CATCH_DEFER(CATCH_REC_NEXT(peek, CATCH_REC_LIST0))(f, peek, __VA_ARGS__)
+#define CATCH_REC_LIST2(f, x, peek, ...)                                                           \
+  f(x) CATCH_DEFER(CATCH_REC_NEXT(peek, CATCH_REC_LIST1))(f, peek, __VA_ARGS__)
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...)                                              \
+  , f(userdata, x)                                                                                 \
+        CATCH_DEFER(CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD))(f, userdata, peek, __VA_ARGS__)
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...)                                              \
+  , f(userdata, x)                                                                                 \
+        CATCH_DEFER(CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD))(f, userdata, peek, __VA_ARGS__)
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)                                              \
+  f(userdata, x)                                                                                   \
+      CATCH_DEFER(CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD))(f, userdata, peek, __VA_ARGS__)
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the
+// results, and passes userdata as the first parameter to each invocation, e.g. CATCH_REC_LIST_UD(f,
+// x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...)                                                        \
+  CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...)                                                                     \
+  CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
 
 #define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO##__VA_ARGS__
 #define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
 #define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
 #define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param)                                             \
+  INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
 #else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+// MSVC is adding extra space and needs another indirection to expand
+// INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
 #define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
 #define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param)                                             \
+  (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
 #endif
 
 #define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
@@ -770,551 +791,946 @@ struct is_unique<T0, T1, Rest...> : std::integral_constant
 #define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...)                                                        \
+  decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...)                                                         \
+  INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
 #else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...)                                                        \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...)                                                         \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
 #endif
 
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)                                             \
+  CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST, __VA_ARGS__)
 
 #define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1)                                                 \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2)                                             \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3)                                         \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4)                                     \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5)                                 \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6)                             \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7)                         \
+  INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8)                     \
+  INTERNAL_CATCH_REMOVE_PARENS(_0),                                                                \
+      INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9)                \
+  INTERNAL_CATCH_REMOVE_PARENS(_0),                                                                \
+      INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10)           \
+  INTERNAL_CATCH_REMOVE_PARENS(_0),                                                                \
+      INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
 
 #define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
 
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    \
-    template<template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2> \
-    constexpr auto append(L1<E1...>, L2<E2...>) noexcept -> L1<E1...,E2...> { return {}; }\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    constexpr auto append(L1<E1...>, L2<E2...>, Rest...) noexcept -> decltype(append(L1<E1...,E2...>{}, Rest{}...)) { return {}; }\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    constexpr auto append(L1<E1...>, TypeList<mpl_::na>, Rest...) noexcept -> L1<E1...> { return {}; }\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    constexpr auto rewrap(List<elems...>) noexcept -> TypeList<Container<elems...>> { return {}; }\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    constexpr auto rewrap(List<Elems...>,Elements...) noexcept -> decltype(append(TypeList<Container<Elems...>>{}, rewrap<Container>(Elements{}...))) { return {}; }\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    constexpr auto create(TypeList<Types...>) noexcept -> decltype(append(Final<>{}, rewrap<Containers>(Types{}...)...)) { return {}; }\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    constexpr auto convert(List<Ts...>) noexcept -> decltype(append(Final<>{},TypeList<Ts>{}...)) { return {}; }
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto rewrap(List<__VA_ARGS__>) noexcept -> TypeList<Container<__VA_ARGS__>> { return {}; }\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    constexpr auto rewrap(List<__VA_ARGS__>,Elements...elems) noexcept -> decltype(append(TypeList<Container<__VA_ARGS__>>{}, rewrap<Container>(elems...))) { return {}; }\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    constexpr auto create(TypeList<Types...>) noexcept -> decltype(append(Final<>{}, rewrap<Containers>(Types{}...)...)) { return {}; }
+#define INTERNAL_CATCH_TYPE_GEN                                                                    \
+  template <typename...> struct TypeList                                                           \
+  {                                                                                                \
+  };                                                                                               \
+  template <typename... Ts> constexpr auto get_wrapper() noexcept->TypeList<Ts...> { return {}; }  \
+  template <template <typename...> class...> struct TemplateTypeList                               \
+  {                                                                                                \
+  };                                                                                               \
+  template <template <typename...> class... Cs>                                                    \
+  constexpr auto get_wrapper() noexcept->TemplateTypeList<Cs...>                                   \
+  {                                                                                                \
+    return {};                                                                                     \
+  }                                                                                                \
+  template <typename...> struct append;                                                            \
+  template <typename...> struct rewrap;                                                            \
+  template <template <typename...> class, typename...> struct create;                              \
+  template <template <typename...> class, typename> struct convert;                                \
+                                                                                                   \
+  template <typename T> struct append<T>                                                           \
+  {                                                                                                \
+    using type = T;                                                                                \
+  };                                                                                               \
+  template <template <typename...> class L1, typename... E1, template <typename...> class L2,      \
+            typename... E2, typename... Rest>                                                      \
+  struct append<L1<E1...>, L2<E2...>, Rest...>                                                     \
+  {                                                                                                \
+    using type = typename append<L1<E1..., E2...>, Rest...>::type;                                 \
+  };                                                                                               \
+  template <template <typename...> class L1, typename... E1, typename... Rest>                     \
+  struct append<L1<E1...>, TypeList<mpl_::na>, Rest...>                                            \
+  {                                                                                                \
+    using type = L1<E1...>;                                                                        \
+  };                                                                                               \
+                                                                                                   \
+  template <template <typename...> class Container, template <typename...> class List,             \
+            typename... elems>                                                                     \
+  struct rewrap<TemplateTypeList<Container>, List<elems...>>                                       \
+  {                                                                                                \
+    using type = TypeList<Container<elems...>>;                                                    \
+  };                                                                                               \
+  template <template <typename...> class Container, template <typename...> class List,             \
+            class... Elems, typename... Elements>                                                  \
+  struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...>                          \
+  {                                                                                                \
+    using type =                                                                                   \
+        typename append<TypeList<Container<Elems...>>,                                             \
+                        typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type;    \
+  };                                                                                               \
+                                                                                                   \
+  template <template <typename...> class Final, template <typename...> class... Containers,        \
+            typename... Types>                                                                     \
+  struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>>                        \
+  {                                                                                                \
+    using type =                                                                                   \
+        typename append<Final<>,                                                                   \
+                        typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type;   \
+  };                                                                                               \
+  template <template <typename...> class Final, template <typename...> class List, typename... Ts> \
+  struct convert<Final, List<Ts...>>                                                               \
+  {                                                                                                \
+    using type = typename append<Final<>, TypeList<Ts>...>::type;                                  \
+  };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)                                                      \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp                                   \
+  {                                                                                                \
+  };                                                                                               \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)>                                               \
+  constexpr auto get_wrapper() noexcept->Nttp<__VA_ARGS__>                                         \
+  {                                                                                                \
+    return {};                                                                                     \
+  }                                                                                                \
+  template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class...>                           \
+  struct NttpTemplateTypeList                                                                      \
+  {                                                                                                \
+  };                                                                                               \
+  template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class... Cs>                        \
+  constexpr auto get_wrapper() noexcept->NttpTemplateTypeList<Cs...>                               \
+  {                                                                                                \
+    return {};                                                                                     \
+  }                                                                                                \
+                                                                                                   \
+  template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container,                    \
+            template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class List,                         \
+            INTERNAL_CATCH_REMOVE_PARENS(signature)>                                               \
+  struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>>                                \
+  {                                                                                                \
+    using type = TypeList<Container<__VA_ARGS__>>;                                                 \
+  };                                                                                               \
+  template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container,                    \
+            template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class List,                         \
+            INTERNAL_CATCH_REMOVE_PARENS(signature), typename... Elements>                         \
+  struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...>                   \
+  {                                                                                                \
+    using type = typename append<                                                                  \
+        TypeList<Container<__VA_ARGS__>>,                                                          \
+        typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type;                \
+  };                                                                                               \
+  template <template <typename...> class Final,                                                    \
+            template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class... Containers,                \
+            typename... Types>                                                                     \
+  struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>>                    \
+  {                                                                                                \
+    using type = typename append<                                                                  \
+        Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type;      \
+  };
 
 #define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)                                      \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)> static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)                                \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)> static void TestName()
 
 #define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)                                       \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)> static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature, ...)                                 \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)> static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)                                         \
+  template <typename Type> void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)           \
+  {                                                                                                \
+    Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO,               \
+                   Catch::StringRef(), nameAndTags);                                               \
+  }
 
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)                                     \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)>                                               \
+  void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)                                 \
+  {                                                                                                \
+    Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO,        \
+                   Catch::StringRef(), nameAndTags);                                               \
+  }
 
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)                             \
+  template <typename Type>                                                                         \
+  void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)        \
+  {                                                                                                \
+    Catch::AutoReg(Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO,         \
+                   className, nameAndTags);                                                        \
+  }
 
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)                              \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)>                                               \
+  void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)     \
+  {                                                                                                \
+    Catch::AutoReg(Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO,  \
+                   className, nameAndTags);                                                        \
+  }
 
 #define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)                    \
+  template <typename TestType> struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> \
+  {                                                                                                \
+    void test();                                                                                   \
+  }
 
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)              \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)>                                               \
+  struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__>                           \
+  {                                                                                                \
+    void test();                                                                                   \
+  }
 
 #define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)                                \
+  template <typename TestType>                                                                     \
+  void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)                          \
+  template <INTERNAL_CATCH_REMOVE_PARENS(signature)>                                               \
+  void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_GEN(...)                                                               \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      __VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__),         \
+      INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__),                      \
+      INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__),                      \
+      INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__),                      \
+      INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__),                      \
+      INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...)                                       \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,                               \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)              \
+  (TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...)                           \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,                              \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)            \
+  (TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...)                                          \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                                   \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)                  \
+  (TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...)                                                 \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER,            \
+      INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER,    \
+      INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER,    \
+      INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)  \
+  (TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...)                                              \
+  INTERNAL_CATCH_VA_NARGS_IMPL("dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X,             \
+                               INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, \
+                               INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, \
+                               INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, \
+                               INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, \
+                               INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)   \
+  (TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...)                                             \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,  \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,                        \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,                        \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,                         \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1,                         \
+      INTERNAL_CATCH_DECLARE_SIG_TEST0)                                                            \
+  (TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...)                                                      \
+  INTERNAL_CATCH_VA_NARGS_IMPL(                                                                    \
+      __VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG, INTERNAL_CATCH_REMOVE_PARENS_10_ARG,       \
+      INTERNAL_CATCH_REMOVE_PARENS_9_ARG, INTERNAL_CATCH_REMOVE_PARENS_8_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_7_ARG, INTERNAL_CATCH_REMOVE_PARENS_6_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_5_ARG, INTERNAL_CATCH_REMOVE_PARENS_4_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_3_ARG, INTERNAL_CATCH_REMOVE_PARENS_2_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_1_ARG)                                                          \
+  (__VA_ARGS__)
 #else
 #define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_GEN(...)                                                               \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      __VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,            \
+      INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,  \
+      INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,                         \
+      INTERNAL_CATCH_NTTP_0)(__VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...)                                       \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,                               \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,            \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1,                                                      \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...)                           \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,                              \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,          \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1,                                                     \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...)                                          \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                                   \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD,                    \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD0,                                                        \
+      INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...)                                                 \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER,            \
+      INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER,    \
+      INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER,    \
+      INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0,                                 \
+      INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...)                                              \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,    \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,                          \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,                          \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,                          \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST1,                           \
+      INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...)                                             \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,  \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,                        \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,                        \
+      INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X,                         \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1,                         \
+      INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...)                                                      \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(                                        \
+      __VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG, INTERNAL_CATCH_REMOVE_PARENS_10_ARG,       \
+      INTERNAL_CATCH_REMOVE_PARENS_9_ARG, INTERNAL_CATCH_REMOVE_PARENS_8_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_7_ARG, INTERNAL_CATCH_REMOVE_PARENS_6_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_5_ARG, INTERNAL_CATCH_REMOVE_PARENS_4_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_3_ARG, INTERNAL_CATCH_REMOVE_PARENS_2_ARG,                      \
+      INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
 #endif
 
 // end catch_preprocessor.hpp
 // start catch_meta.hpp
 
-
 #include <type_traits>
 
 namespace Catch {
-template<typename T>
-struct always_false : std::false_type {};
-
-template <typename> struct true_given : std::true_type {};
-struct is_callable_tester {
+  template <typename T> struct always_false : std::false_type
+  {
+  };
+
+  template <typename> struct true_given : std::true_type
+  {
+  };
+  struct is_callable_tester
+  {
     template <typename Fun, typename... Args>
     true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-    template <typename...>
-    std::false_type static test(...);
-};
+    template <typename...> std::false_type static test(...);
+  };
 
-template <typename T>
-struct is_callable;
+  template <typename T> struct is_callable;
 
-template <typename Fun, typename... Args>
-struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+  template <typename Fun, typename... Args>
+  struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0))
+  {
+  };
 
 } // namespace Catch
 
-namespace mpl_{
-    struct na;
+namespace mpl_ {
+  struct na;
 }
 
 // end catch_meta.hpp
 namespace Catch {
 
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
+  template <typename C> class TestInvokerAsMethod : public ITestInvoker
+  {
     void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
 
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
+  public:
+    TestInvokerAsMethod(void (C::*testAsMethod)()) noexcept : m_testAsMethod(testAsMethod) {}
+
+    void invoke() const override
+    {
+      C obj;
+      (obj.*m_testAsMethod)();
     }
-};
+  };
 
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+  auto makeTestInvoker(void (*testAsFunction)()) noexcept -> ITestInvoker *;
 
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
-}
+  template <typename C> auto makeTestInvoker(void (C::*testAsMethod)()) noexcept -> ITestInvoker *
+  {
+    return new (std::nothrow) TestInvokerAsMethod<C>(testAsMethod);
+  }
 
-struct NameAndTags {
-    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+  struct NameAndTags
+  {
+    NameAndTags(StringRef const &name_ = StringRef(),
+                StringRef const &tags_ = StringRef()) noexcept;
     StringRef name;
     StringRef tags;
-};
+  };
 
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+  struct AutoReg : NonCopyable
+  {
+    AutoReg(ITestInvoker *invoker, SourceLineInfo const &lineInfo, StringRef const &classOrMethod,
+            NameAndTags const &nameAndTags) noexcept;
     ~AutoReg();
-};
+  };
 
 } // end namespace Catch
 
 #if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
+#define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(TestName, ...) static void TestName()
+#define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(TestName, ClassName, ...)                   \
+  namespace {                                                                                      \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)                                      \
+    {                                                                                              \
+      void test();                                                                                 \
+    };                                                                                             \
+  }                                                                                                \
+  void TestName::test()
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2(TestName, TestFunc, Name, Tags,        \
+                                                            Signature, ...)                        \
+  INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2(                                \
+    TestNameClass, TestName, ClassName, Name, Tags, Signature, ...)                                \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                                              \
+    {                                                                                              \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName,                                  \
+                                             INTERNAL_CATCH_REMOVE_PARENS(Signature));             \
+    }                                                                                              \
+  }                                                                                                \
+  INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...)                         \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2(                                             \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, typename TestType, __VA_ARGS__)
+#else
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...)                         \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2(                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, typename TestType, __VA_ARGS__))
 #endif
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...)          \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2(                                             \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, Signature, __VA_ARGS__)
+#else
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...)          \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2(                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, Signature, __VA_ARGS__))
+#endif
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(ClassName, Name, Tags, ...)       \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2(                                      \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, typename T, __VA_ARGS__)
+#else
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(ClassName, Name, Tags, ...)       \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2(          \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, typename T, __VA_ARGS__))
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(ClassName, Name, Tags,        \
+                                                                     Signature, ...)               \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2(                                      \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, Signature, __VA_ARGS__)
+#else
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(ClassName, Name, Tags,        \
+                                                                     Signature, ...)               \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2(          \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, Signature, __VA_ARGS__))
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TESTCASE2(TestName, ...)                                                    \
+  static void TestName();                                                                          \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(Catch::makeTestInvoker(&TestName),    \
+                                                             CATCH_INTERNAL_LINEINFO,              \
+                                                             Catch::StringRef(),                   \
+                                                             Catch::NameAndTags{__VA_ARGS__});     \
+  } /* NOLINT */                                                                                   \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  static void TestName()
+#define INTERNAL_CATCH_TESTCASE(...)                                                               \
+  INTERNAL_CATCH_TESTCASE2(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____), __VA_ARGS__)
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_METHOD_AS_TEST_CASE(QualifiedMethod, ...)                                   \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    Catch::AutoReg                                                                                 \
+        INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(Catch::makeTestInvoker(&QualifiedMethod),        \
+                                                  CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod,   \
+                                                  Catch::NameAndTags{__VA_ARGS__});                \
+  } /* NOLINT */                                                                                   \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST_CASE_METHOD2(TestName, ClassName, ...)                                 \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)                                      \
+    {                                                                                              \
+      void test();                                                                                 \
+    };                                                                                             \
+    Catch::AutoReg                                                                                 \
+        INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(Catch::makeTestInvoker(&TestName::test),         \
+                                                  CATCH_INTERNAL_LINEINFO, #ClassName,             \
+                                                  Catch::NameAndTags{__VA_ARGS__}); /* NOLINT */   \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  void TestName::test()
+#define INTERNAL_CATCH_TEST_CASE_METHOD(ClassName, ...)                                            \
+  INTERNAL_CATCH_TEST_CASE_METHOD2(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____),       \
+                                   ClassName, __VA_ARGS__)
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_REGISTER_TESTCASE(Function, ...)                                            \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(                                        \
+      Catch::makeTestInvoker(Function), CATCH_INTERNAL_LINEINFO, Catch::StringRef(),               \
+      Catch::NameAndTags{__VA_ARGS__}); /* NOLINT */                                               \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ...)        \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                                                   \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                                 \
+  INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));              \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                                              \
+    {                                                                                              \
+      INTERNAL_CATCH_TYPE_GEN                                                                      \
+      INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))                             \
+      INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))               \
+      template <typename... Types> struct TestName                                                 \
+      {                                                                                            \
+        TestName()                                                                                 \
+        {                                                                                          \
+          int                   index        = 0;                                                  \
+          constexpr char const *tmpl_types[] = {                                                   \
+              CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};               \
+          using expander = int[];                                                                  \
+          (void)expander{                                                                          \
+              (reg_test(Types{},                                                                   \
+                        Catch::NameAndTags{Name " - " + std::string(tmpl_types[index]), Tags}),    \
+               index++, 0)...}; /* NOLINT */                                                       \
+        }                                                                                          \
+      };                                                                                           \
+      static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {                              \
+        TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();                        \
+        return 0;                                                                                  \
+      }();                                                                                         \
+    }                                                                                              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS                                                 \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS                                               \
+  INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...)                                         \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(                                                             \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, typename TestType, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...)                                         \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(                                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, typename TestType, __VA_ARGS__))
 #endif
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...)                          \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(                                                             \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, Signature, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...)                          \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(                                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, Signature, __VA_ARGS__))
 #endif
 
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    int index = 0;                                    \
-                    using expander = int[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = decltype(create<TestName, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>{})); \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                    \
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS              \
-        template<typename TestType>                                   \
-        static void TestFuncName()
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature,  \
+                                                   TmplTypes, TypesList)                           \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                                                   \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                                 \
+  template <typename TestType> static void TestFuncName();                                         \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                                              \
+    {                                                                                              \
+      INTERNAL_CATCH_TYPE_GEN                                                                      \
+      INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))                             \
+      template <typename... Types> struct TestName                                                 \
+      {                                                                                            \
+        void reg_tests()                                                                           \
+        {                                                                                          \
+          int index                          = 0;                                                  \
+          using expander                     = int[];                                              \
+          constexpr char const *tmpl_types[] = {CATCH_REC_LIST(                                    \
+              INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};  \
+          constexpr char const *types_list[] = {CATCH_REC_LIST(                                    \
+              INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};  \
+          constexpr auto        num_types    = sizeof(types_list) / sizeof(types_list[0]);         \
+          (void)expander{                                                                          \
+              (Catch::AutoReg(                                                                     \
+                   Catch::makeTestInvoker(&TestFuncName<Types>), CATCH_INTERNAL_LINEINFO,          \
+                   Catch::StringRef(),                                                             \
+                   Catch::NameAndTags{Name " - " + std::string(tmpl_types[index / num_types]) +    \
+                                          "<" + std::string(types_list[index % num_types]) + ">",  \
+                                      Tags}),                                                      \
+               index++, 0)...}; /* NOLINT */                                                       \
+        }                                                                                          \
+      };                                                                                           \
+      static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {                              \
+        using TestInit =                                                                           \
+            typename create<TestName,                                                              \
+                            decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()),      \
+                            TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(                    \
+                                INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;                  \
+        TestInit t;                                                                                \
+        t.reg_tests();                                                                             \
+        return 0;                                                                                  \
+      }();                                                                                         \
+    }                                                                                              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS                                                 \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS                                               \
+  template <typename TestType> static void TestFuncName()
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)                                 \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(                                                      \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, typename T, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)                                 \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(                          \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, typename T, __VA_ARGS__))
 #endif
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)                  \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(                                                      \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, Signature, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)                  \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(                          \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, Signature, __VA_ARGS__))
 #endif
 
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                int index = 0;                                    \
-                using expander = int[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = decltype(convert<TestName>(std::declval<TmplList>())); \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                        \
-        }}\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                    \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS\
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS\
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)         \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                                 \
+  template <typename TestType> static void TestFunc();                                             \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                                              \
+    {                                                                                              \
+      INTERNAL_CATCH_TYPE_GEN                                                                      \
+      template <typename... Types> struct TestName                                                 \
+      {                                                                                            \
+        void reg_tests()                                                                           \
+        {                                                                                          \
+          int index      = 0;                                                                      \
+          using expander = int[];                                                                  \
+          (void)expander{                                                                          \
+              (Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<Types>), CATCH_INTERNAL_LINEINFO,   \
+                              Catch::StringRef(),                                                  \
+                              Catch::NameAndTags{                                                  \
+                                  Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) +   \
+                                      " - " + std::to_string(index),                               \
+                                  Tags}),                                                          \
+               index++, 0)...}; /* NOLINT */                                                       \
+        }                                                                                          \
+      };                                                                                           \
+      static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {                              \
+        using TestInit = typename convert<TestName, TmplList>::type;                               \
+        TestInit t;                                                                                \
+        t.reg_tests();                                                                             \
+        return 0;                                                                                  \
+      }();                                                                                         \
+    }                                                                                              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS                                               \
+  template <typename TestType> static void TestFunc()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList)                               \
+  INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(                                                        \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      Name, Tags, TmplList)
+
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, \
+                                                   Signature, ...)                                 \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                                                   \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                                 \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                                              \
+    {                                                                                              \
+      INTERNAL_CATCH_TYPE_GEN                                                                      \
+      INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))                             \
+      INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName,                                  \
+                                             INTERNAL_CATCH_REMOVE_PARENS(Signature));             \
+      INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))        \
+      template <typename... Types> struct TestNameClass                                            \
+      {                                                                                            \
+        TestNameClass()                                                                            \
+        {                                                                                          \
+          int                   index        = 0;                                                  \
+          constexpr char const *tmpl_types[] = {                                                   \
+              CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};               \
+          using expander = int[];                                                                  \
+          (void)expander{                                                                          \
+              (reg_test(Types{}, #ClassName,                                                       \
+                        Catch::NameAndTags{Name " - " + std::string(tmpl_types[index]), Tags}),    \
+               index++, 0)...}; /* NOLINT */                                                       \
+        }                                                                                          \
+      };                                                                                           \
+      static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {                              \
+        TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();                   \
+        return 0;                                                                                  \
+      }();                                                                                         \
+    }                                                                                              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS                                                 \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS                                               \
+  INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(ClassName, Name, Tags, ...)                       \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2(                                                      \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, typename T, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(ClassName, Name, Tags, ...)                       \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2(                          \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, typename T, __VA_ARGS__))
 #endif
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(ClassName, Name, Tags, Signature, ...)        \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2(                                                      \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, Signature, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(ClassName, Name, Tags, Signature, ...)        \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2(                          \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____),    \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____), ClassName,      \
+      Name, Tags, Signature, __VA_ARGS__))
 #endif
 
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = decltype(create<TestNameClass, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>{}));\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
-        template<typename TestType> \
-        void TestName<TestType>::test()
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(                                        \
+    TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)               \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                                                   \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                                 \
+  template <typename TestType> struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName<TestType>) \
+  {                                                                                                \
+    void test();                                                                                   \
+  };                                                                                               \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass)                                         \
+    {                                                                                              \
+      INTERNAL_CATCH_TYPE_GEN                                                                      \
+      INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))                             \
+      template <typename... Types> struct TestNameClass                                            \
+      {                                                                                            \
+        void reg_tests()                                                                           \
+        {                                                                                          \
+          int index                          = 0;                                                  \
+          using expander                     = int[];                                              \
+          constexpr char const *tmpl_types[] = {CATCH_REC_LIST(                                    \
+              INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};  \
+          constexpr char const *types_list[] = {CATCH_REC_LIST(                                    \
+              INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};  \
+          constexpr auto        num_types    = sizeof(types_list) / sizeof(types_list[0]);         \
+          (void)expander{                                                                          \
+              (Catch::AutoReg(                                                                     \
+                   Catch::makeTestInvoker(&TestName<Types>::test), CATCH_INTERNAL_LINEINFO,        \
+                   #ClassName,                                                                     \
+                   Catch::NameAndTags{Name " - " + std::string(tmpl_types[index / num_types]) +    \
+                                          "<" + std::string(types_list[index % num_types]) + ">",  \
+                                      Tags}),                                                      \
+               index++, 0)...}; /* NOLINT */                                                       \
+        }                                                                                          \
+      };                                                                                           \
+      static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {                              \
+        using TestInit =                                                                           \
+            typename create<TestNameClass,                                                         \
+                            decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()),      \
+                            TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(                    \
+                                INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;                  \
+        TestInit t;                                                                                \
+        t.reg_tests();                                                                             \
+        return 0;                                                                                  \
+      }();                                                                                         \
+    }                                                                                              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS                                                 \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS                                               \
+  template <typename TestType> void TestName<TestType>::test()
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(ClassName, Name, Tags, ...)               \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(                                              \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      ClassName, Name, Tags, typename T, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(ClassName, Name, Tags, ...)               \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(                  \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      ClassName, Name, Tags, typename T, __VA_ARGS__))
 #endif
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(ClassName, Name, Tags, Signature,     \
+                                                             ...)                                  \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(                                              \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      ClassName, Name, Tags, Signature, __VA_ARGS__)
 #else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(ClassName, Name, Tags, Signature,     \
+                                                             ...)                                  \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(                  \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      ClassName, Name, Tags, Signature, __VA_ARGS__))
 #endif
 
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = decltype(convert<TestNameClass>(std::declval<TmplList>()));\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name,  \
+                                                        Tags, TmplList)                            \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                                                 \
+  template <typename TestType> struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName<TestType>) \
+  {                                                                                                \
+    void test();                                                                                   \
+  };                                                                                               \
+  namespace {                                                                                      \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                                              \
+    {                                                                                              \
+      INTERNAL_CATCH_TYPE_GEN                                                                      \
+      template <typename... Types> struct TestNameClass                                            \
+      {                                                                                            \
+        void reg_tests()                                                                           \
+        {                                                                                          \
+          int index      = 0;                                                                      \
+          using expander = int[];                                                                  \
+          (void)expander{                                                                          \
+              (Catch::AutoReg(Catch::makeTestInvoker(&TestName<Types>::test),                      \
+                              CATCH_INTERNAL_LINEINFO, #ClassName,                                 \
+                              Catch::NameAndTags{                                                  \
+                                  Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) +   \
+                                      " - " + std::to_string(index),                               \
+                                  Tags}),                                                          \
+               index++, 0)...}; /* NOLINT */                                                       \
+        }                                                                                          \
+      };                                                                                           \
+      static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {                              \
+        using TestInit = typename convert<TestNameClass, TmplList>::type;                          \
+        TestInit t;                                                                                \
+        t.reg_tests();                                                                             \
+        return 0;                                                                                  \
+      }();                                                                                         \
+    }                                                                                              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_TEMPLATE_WARNINGS                                               \
+  template <typename TestType> void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList)             \
+  INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2(                                                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____),                 \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____),      \
+      ClassName, Name, Tags, TmplList)
 
 // end catch_test_registry.h
 // start catch_capture.hpp
@@ -1327,61 +1743,67 @@ struct AutoReg : NonCopyable {
 
 namespace Catch {
 
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
+  // ResultWas::OfType enum
+  struct ResultWas
+  {
+    enum OfType {
+      Unknown = -1,
+      Ok      = 0,
+      Info    = 1,
+      Warning = 2,
 
-        FailureBit = 0x10,
+      FailureBit = 0x10,
 
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
+      ExpressionFailed = FailureBit | 1,
+      ExplicitFailure  = FailureBit | 2,
 
-        Exception = 0x100 | FailureBit,
+      Exception = 0x100 | FailureBit,
 
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
+      ThrewException      = Exception | 1,
+      DidntThrowException = Exception | 2,
 
-        FatalErrorCondition = 0x200 | FailureBit
+      FatalErrorCondition = 0x200 | FailureBit
 
-    }; };
+    };
+  };
 
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
+  bool isOk(ResultWas::OfType resultType);
+  bool isJustInfo(int flags);
 
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
+  // ResultDisposition::Flags enum
+  struct ResultDisposition
+  {
+    enum Flags {
+      Normal = 0x01,
 
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
+      ContinueOnFailure = 0x02, // Failures fail test, but execution continues
+      FalseTest         = 0x04, // Prefix expression with !
+      SuppressFail      = 0x08  // Failures are reported but do not fail the test
+    };
+  };
 
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+  ResultDisposition::Flags operator|(ResultDisposition::Flags lhs, ResultDisposition::Flags rhs);
 
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
+  bool        shouldContinueOnFailure(int flags);
+  inline bool isFalseTest(int flags) { return (flags & ResultDisposition::FalseTest) != 0; }
+  bool        shouldSuppressFailure(int flags);
 
 } // end namespace Catch
 
 // end catch_result_type.h
 namespace Catch {
 
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
+  struct AssertionInfo
+  {
+    StringRef                macroName;
+    SourceLineInfo           lineInfo;
+    StringRef                capturedExpression;
+    ResultDisposition::Flags resultDisposition;
 
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
+    // We want to delete this constructor but a compiler bug in 4.8 means
+    // the struct is then treated as non-aggregate
+    // AssertionInfo() = delete;
+  };
 
 } // end namespace Catch
 
@@ -1390,48 +1812,51 @@ namespace Catch {
 
 // start catch_tostring.h
 
-#include <vector>
 #include <cstddef>
-#include <type_traits>
 #include <string>
+#include <type_traits>
+#include <vector>
 // start catch_stream.h
 
-#include <iosfwd>
 #include <cstddef>
+#include <iosfwd>
 #include <ostream>
 
 namespace Catch {
 
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
+  std::ostream &cout();
+  std::ostream &cerr();
+  std::ostream &clog();
 
-    class StringRef;
+  class StringRef;
 
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
+  struct IStream
+  {
+    virtual ~IStream();
+    virtual std::ostream &stream() const = 0;
+  };
 
-    auto makeStream( StringRef const &filename ) -> IStream const*;
+  auto makeStream(StringRef const &filename) -> IStream const *;
 
-    class ReusableStringStream {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
+  class ReusableStringStream
+  {
+    std::size_t   m_index;
+    std::ostream *m_oss;
 
-        auto str() const -> std::string;
+  public:
+    ReusableStringStream();
+    ~ReusableStringStream();
 
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
+    auto str() const -> std::string;
+
+    template <typename T> auto operator<<(T const &value) -> ReusableStringStream &
+    {
+      *m_oss << value;
+      return *this;
+    }
+    auto get() -> std::ostream & { return *m_oss; }
+  };
+} // namespace Catch
 
 // end catch_stream.h
 // start catch_interfaces_enum_values_registry.h
@@ -1440,33 +1865,39 @@ namespace Catch {
 
 namespace Catch {
 
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, std::string>> m_values;
+  namespace Detail {
+    struct EnumInfo
+    {
+      StringRef                              m_name;
+      std::vector<std::pair<int, StringRef>> m_values;
 
-            ~EnumInfo();
+      ~EnumInfo();
 
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
+      StringRef lookup(int value) const;
+    };
+  } // namespace Detail
 
-    struct IMutableEnumValuesRegistry {
-        virtual ~IMutableEnumValuesRegistry();
+  struct IMutableEnumValuesRegistry
+  {
+    virtual ~IMutableEnumValuesRegistry();
 
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+    virtual Detail::EnumInfo const &registerEnum(StringRef enumName, StringRef allEnums,
+                                                 std::vector<int> const &values) = 0;
 
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
+    template <typename E>
+    Detail::EnumInfo const &registerEnum(StringRef enumName, StringRef allEnums,
+                                         std::initializer_list<E> values)
+    {
+      static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+      std::vector<int> intValues;
+      intValues.reserve(values.size());
+      for (auto enumValue : values)
+        intValues.push_back(static_cast<int>(enumValue));
+      return registerEnum(enumName, allEnums, intValues);
+    }
+  };
 
-} // Catch
+} // namespace Catch
 
 // end catch_interfaces_enum_values_registry.h
 
@@ -1485,33 +1916,33 @@ namespace Catch {
 #define CATCH_ARC_ENABLED 0
 #endif
 
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
+void arcSafeRelease(NSObject *obj);
+id   performOptionalSelector(id obj, SEL sel);
 
 #if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
+inline void arcSafeRelease(NSObject *obj) { [obj release]; }
+inline id   performOptionalSelector(id obj, SEL sel)
+{
+  if ([obj respondsToSelector:sel])
+    return [obj performSelector:sel];
+  return nil;
 }
 #define CATCH_UNSAFE_UNRETAINED
 #define CATCH_ARC_STRONG
 #else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
+inline void arcSafeRelease(NSObject *) {}
+inline id   performOptionalSelector(id obj, SEL sel)
+{
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
 #endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
+  if ([obj respondsToSelector:sel])
+    return [obj performSelector:sel];
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
-    return nil;
+  return nil;
 }
 #define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
 #define CATCH_ARC_STRONG __strong
@@ -1522,322 +1953,333 @@ inline id performOptionalSelector( id obj, SEL sel ) {
 
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#pragma warning(disable : 4180) // We attempt to stream a function (address) by const&, which MSVC
+                                // complains about but is harmless
 #endif
 
 namespace Catch {
-    namespace Detail {
+  namespace Detail {
 
-        extern const std::string unprintableString;
+    extern const std::string unprintableString;
 
-        std::string rawMemoryToString( const void *object, std::size_t size );
+    std::string rawMemoryToString(const void *object, std::size_t size);
 
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
+    template <typename T> std::string rawMemoryToString(const T &object)
+    {
+      return rawMemoryToString(&object, sizeof(object));
+    }
 
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename SS, typename TT>
-            static auto test(int)
-                -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
+    template <typename T> class IsStreamInsertable
+    {
+      template <typename Stream, typename U>
+      static auto test(int)
+          -> decltype(std::declval<Stream &>() << std::declval<U>(), std::true_type());
 
-            template<typename, typename>
-            static auto test(...)->std::false_type;
+      template <typename, typename> static auto test(...) -> std::false_type;
 
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
+    public:
+      static const bool value = decltype(test<std::ostream, const T &>(0))::value;
+    };
 
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
+    template <typename E> std::string convertUnknownEnumToString(E e);
 
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
-            return Detail::unprintableString;
-        }
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
+    template <typename T>
+    typename std::enable_if<!std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+                            std::string>::type
+    convertUnstreamable(T const &)
+    {
+      return Detail::unprintableString;
+    }
+    template <typename T>
+    typename std::enable_if<!std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+                            std::string>::type
+    convertUnstreamable(T const &ex)
+    {
+      return ex.what();
+    }
 
-        template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
+    template <typename T>
+    typename std::enable_if<std::is_enum<T>::value, std::string>::type
+    convertUnstreamable(T const &value)
+    {
+      return convertUnknownEnumToString(value);
+    }
 
 #if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
+    //! Convert a CLR string to a utf8 std::string
+    template <typename T> std::string clrReferenceToString(T ^ ref)
+    {
+      if (ref == nullptr)
+        return std::string("null");
+      auto                       bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+      cli::pin_ptr<System::Byte> p     = &bytes[0];
+      return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+    }
 #endif
 
-    } // namespace Detail
+  } // namespace Detail
 
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
+  // If we decide for C++14, change these to enable_if_ts
+  template <typename T, typename = void> struct StringMaker
+  {
+    template <typename Fake = T>
+    static
         typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
+        convert(const Fake &value)
+    {
+      ReusableStringStream rss;
+      // NB: call using the function-like syntax to avoid ambiguity with
+      // user-defined templated operator<< under clang.
+      rss.operator<<(value);
+      return rss.str();
+    }
 
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert( const Fake& value ) {
+    template <typename Fake = T>
+    static typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value,
+                                   std::string>::type
+    convert(const Fake &value)
+    {
 #if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
+      return Detail::convertUnstreamable(value);
 #else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+      return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
 #endif
-        }
-    };
+    }
+  };
 
-    namespace Detail {
+  namespace Detail {
 
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
+    // This function dispatches all stringification requests inside of Catch.
+    // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+    template <typename T> std::string stringify(const T &e)
+    {
+      return ::Catch::StringMaker<
+          typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+    }
 
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
-        }
+    template <typename E> std::string convertUnknownEnumToString(E e)
+    {
+      return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+    }
 
 #if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
+    template <typename T> std::string stringify(T ^ e)
+    {
+      return ::Catch::StringMaker<T ^>::convert(e);
+    }
 #endif
 
-    } // namespace Detail
+  } // namespace Detail
 
-    // Some predefined specializations
+  // Some predefined specializations
 
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
+  template <> struct StringMaker<std::string>
+  {
+    static std::string convert(const std::string &str);
+  };
 
 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
+  template <> struct StringMaker<std::string_view>
+  {
+    static std::string convert(std::string_view str);
+  };
 #endif
 
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
+  template <> struct StringMaker<char const *>
+  {
+    static std::string convert(char const *str);
+  };
+  template <> struct StringMaker<char *>
+  {
+    static std::string convert(char *str);
+  };
 
 #ifdef CATCH_CONFIG_WCHAR
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
+  template <> struct StringMaker<std::wstring>
+  {
+    static std::string convert(const std::wstring &wstr);
+  };
 
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+  template <> struct StringMaker<std::wstring_view>
+  {
+    static std::string convert(std::wstring_view str);
+  };
 #endif
 
-    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
-    //      while keeping string semantics?
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
+  template <> struct StringMaker<wchar_t const *>
+  {
+    static std::string convert(wchar_t const *str);
+  };
+  template <> struct StringMaker<wchar_t *>
+  {
+    static std::string convert(wchar_t *str);
+  };
+#endif
+
+  // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+  //      while keeping string semantics?
+  template <int SZ> struct StringMaker<char[SZ]>
+  {
+    static std::string convert(char const *str)
+    {
+      return ::Catch::Detail::stringify(std::string{str});
+    }
+  };
+  template <int SZ> struct StringMaker<signed char[SZ]>
+  {
+    static std::string convert(signed char const *str)
+    {
+      return ::Catch::Detail::stringify(std::string{reinterpret_cast<char const *>(str)});
+    }
+  };
+  template <int SZ> struct StringMaker<unsigned char[SZ]>
+  {
+    static std::string convert(unsigned char const *str)
+    {
+      return ::Catch::Detail::stringify(std::string{reinterpret_cast<char const *>(str)});
+    }
+  };
 
 #if defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<std::byte> {
-        static std::string convert(std::byte value);
-    };
+  template <> struct StringMaker<std::byte>
+  {
+    static std::string convert(std::byte value);
+  };
 #endif // defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
+  template <> struct StringMaker<int>
+  {
+    static std::string convert(int value);
+  };
+  template <> struct StringMaker<long>
+  {
+    static std::string convert(long value);
+  };
+  template <> struct StringMaker<long long>
+  {
+    static std::string convert(long long value);
+  };
+  template <> struct StringMaker<unsigned int>
+  {
+    static std::string convert(unsigned int value);
+  };
+  template <> struct StringMaker<unsigned long>
+  {
+    static std::string convert(unsigned long value);
+  };
+  template <> struct StringMaker<unsigned long long>
+  {
+    static std::string convert(unsigned long long value);
+  };
+
+  template <> struct StringMaker<bool>
+  {
+    static std::string convert(bool b);
+  };
+
+  template <> struct StringMaker<char>
+  {
+    static std::string convert(char c);
+  };
+  template <> struct StringMaker<signed char>
+  {
+    static std::string convert(signed char c);
+  };
+  template <> struct StringMaker<unsigned char>
+  {
+    static std::string convert(unsigned char c);
+  };
+
+  template <> struct StringMaker<std::nullptr_t>
+  {
+    static std::string convert(std::nullptr_t);
+  };
+
+  template <> struct StringMaker<float>
+  {
+    static std::string convert(float value);
+    static int         precision;
+  };
+
+  template <> struct StringMaker<double>
+  {
+    static std::string convert(double value);
+    static int         precision;
+  };
+
+  template <typename T> struct StringMaker<T *>
+  {
+    template <typename U> static std::string convert(U *p)
+    {
+      if (p) {
+        return ::Catch::Detail::rawMemoryToString(p);
+      }
+      else {
+        return "nullptr";
+      }
+    }
+  };
+
+  template <typename R, typename C> struct StringMaker<R C::*>
+  {
+    static std::string convert(R C::*p)
+    {
+      if (p) {
+        return ::Catch::Detail::rawMemoryToString(p);
+      }
+      else {
+        return "nullptr";
+      }
+    }
+  };
 
 #if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
+  template <typename T> struct StringMaker<T ^>
+  {
+    static std::string convert(T ^ ref) { return ::Catch::Detail::clrReferenceToString(ref); }
+  };
 #endif
 
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
+  namespace Detail {
+    template <typename InputIterator>
+    std::string rangeToString(InputIterator first, InputIterator last)
+    {
+      ReusableStringStream rss;
+      rss << "{ ";
+      if (first != last) {
+        rss << ::Catch::Detail::stringify(*first);
+        for (++first; first != last; ++first)
+          rss << ", " << ::Catch::Detail::stringify(*first);
+      }
+      rss << " }";
+      return rss.str();
+    }
+  } // namespace Detail
 
 #ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
+  template <> struct StringMaker<NSString *>
+  {
+    static std::string convert(NSString *nsstring)
+    {
+      if (!nsstring)
+        return "nil";
+      return std::string("@") + [nsstring UTF8String];
+    }
+  };
+  template <> struct StringMaker<NSObject *>
+  {
+    static std::string convert(NSObject *nsObject)
+    {
+      return ::Catch::Detail::stringify([nsObject description]);
+    }
+  };
+  namespace Detail {
+    inline std::string stringify(NSString *nsstring)
+    {
+      return StringMaker<NSString *>::convert(nsstring);
+    }
 
-    } // namespace Detail
+  }    // namespace Detail
 #endif // __OBJC__
 
 } // namespace Catch
@@ -1847,309 +2289,314 @@ namespace Catch {
 // This means that we do not bring in
 
 #if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
 #endif
 
 // Separate std::pair specialization
 #if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
 #include <utility>
 namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
+  template <typename T1, typename T2> struct StringMaker<std::pair<T1, T2>>
+  {
+    static std::string convert(const std::pair<T1, T2> &pair)
+    {
+      ReusableStringStream rss;
+      rss << "{ " << ::Catch::Detail::stringify(pair.first) << ", "
+          << ::Catch::Detail::stringify(pair.second) << " }";
+      return rss.str();
+    }
+  };
+} // namespace Catch
 #endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
 
 #if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
 #include <optional>
 namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            ReusableStringStream rss;
-            if (optional.has_value()) {
-                rss << ::Catch::Detail::stringify(*optional);
-            } else {
-                rss << "{ }";
-            }
-            return rss.str();
-        }
-    };
-}
+  template <typename T> struct StringMaker<std::optional<T>>
+  {
+    static std::string convert(const std::optional<T> &optional)
+    {
+      ReusableStringStream rss;
+      if (optional.has_value()) {
+        rss << ::Catch::Detail::stringify(*optional);
+      }
+      else {
+        rss << "{ }";
+      }
+      return rss.str();
+    }
+  };
+} // namespace Catch
 #endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
 
 // Separate std::tuple specialization
 #if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
 #include <tuple>
 namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
+  namespace Detail {
+    template <typename Tuple, std::size_t N = 0, bool = (N < std::tuple_size<Tuple>::value)>
+    struct TupleElementPrinter
+    {
+      static void print(const Tuple &tuple, std::ostream &os)
+      {
+        os << (N ? ", " : " ") << ::Catch::Detail::stringify(std::get<N>(tuple));
+        TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+      }
+    };
 
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
+    template <typename Tuple, std::size_t N> struct TupleElementPrinter<Tuple, N, false>
+    {
+      static void print(const Tuple &, std::ostream &) {}
+    };
 
-    }
+  } // namespace Detail
 
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
+  template <typename... Types> struct StringMaker<std::tuple<Types...>>
+  {
+    static std::string convert(const std::tuple<Types...> &tuple)
+    {
+      ReusableStringStream rss;
+      rss << '{';
+      Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+      rss << " }";
+      return rss.str();
+    }
+  };
+} // namespace Catch
 #endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
 
 #if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
 #include <variant>
 namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
+  template <> struct StringMaker<std::monostate>
+  {
+    static std::string convert(const std::monostate &) { return "{ }"; }
+  };
+
+  template <typename... Elements> struct StringMaker<std::variant<Elements...>>
+  {
+    static std::string convert(const std::variant<Elements...> &variant)
+    {
+      if (variant.valueless_by_exception()) {
+        return "{valueless variant}";
+      }
+      else {
+        return std::visit([](const auto &value) { return ::Catch::Detail::stringify(value); },
+                          variant);
+      }
+    }
+  };
+} // namespace Catch
 #endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
 
 namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
+  struct not_this_one
+  {
+  }; // Tag type for detecting which begin/ end are being selected
 
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
-    using std::end;
+  // Import begin/ end from std here so they are considered alongside the fallback (...) overloads
+  // in this namespace
+  using std::begin;
+  using std::end;
 
-    not_this_one begin( ... );
-    not_this_one end( ... );
+  not_this_one begin(...);
+  not_this_one end(...);
 
-    template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
-    };
+  template <typename T> struct is_range
+  {
+    static const bool value =
+        !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
+        !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+  };
 
 #if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
+  template <typename T> struct is_range<T ^>
+  {
+    static const bool value = false;
+  };
 #endif
 
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
+  template <typename Range> std::string rangeToString(Range const &range)
+  {
+    return ::Catch::Detail::rangeToString(begin(range), end(range));
+  }
 
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
+  // Handle vector<bool> specially
+  template <typename Allocator> std::string rangeToString(std::vector<bool, Allocator> const &v)
+  {
+    ReusableStringStream rss;
+    rss << "{ ";
+    bool first = true;
+    for (bool b : v) {
+      if (first)
+        first = false;
+      else
+        rss << ", ";
+      rss << ::Catch::Detail::stringify(b);
+    }
+    rss << " }";
+    return rss.str();
+  }
 
-    template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
+  template <typename R>
+  struct StringMaker<R,
+                     typename std::enable_if<is_range<R>::value &&
+                                             !::Catch::Detail::IsStreamInsertable<R>::value>::type>
+  {
+    static std::string convert(R const &range) { return rangeToString(range); }
+  };
 
-    template <typename T, int SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
+  template <typename T, int SZ> struct StringMaker<T[SZ]>
+  {
+    static std::string convert(T const (&arr)[SZ]) { return rangeToString(arr); }
+  };
 
 } // namespace Catch
 
 // Separate std::chrono::duration specialization
 #if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#include <chrono>
 #include <ctime>
 #include <ratio>
-#include <chrono>
 
 namespace Catch {
 
-template <class Ratio>
-struct ratio_string {
+  template <class Ratio> struct ratio_string
+  {
     static std::string symbol();
-};
+  };
 
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
+  template <class Ratio> std::string ratio_string<Ratio>::symbol()
+  {
     Catch::ReusableStringStream rss;
-    rss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
+    rss << '[' << Ratio::num << '/' << Ratio::den << ']';
     return rss.str();
-}
-template <>
-struct ratio_string<std::atto> {
+  }
+  template <> struct ratio_string<std::atto>
+  {
     static std::string symbol();
-};
-template <>
-struct ratio_string<std::femto> {
+  };
+  template <> struct ratio_string<std::femto>
+  {
     static std::string symbol();
-};
-template <>
-struct ratio_string<std::pico> {
+  };
+  template <> struct ratio_string<std::pico>
+  {
     static std::string symbol();
-};
-template <>
-struct ratio_string<std::nano> {
+  };
+  template <> struct ratio_string<std::nano>
+  {
     static std::string symbol();
-};
-template <>
-struct ratio_string<std::micro> {
+  };
+  template <> struct ratio_string<std::micro>
+  {
     static std::string symbol();
-};
-template <>
-struct ratio_string<std::milli> {
+  };
+  template <> struct ratio_string<std::milli>
+  {
     static std::string symbol();
-};
+  };
 
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
+  ////////////
+  // std::chrono::duration specializations
+  template <typename Value, typename Ratio> struct StringMaker<std::chrono::duration<Value, Ratio>>
+  {
+    static std::string convert(std::chrono::duration<Value, Ratio> const &duration)
+    {
+      ReusableStringStream rss;
+      rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+      return rss.str();
+    }
+  };
+  template <typename Value> struct StringMaker<std::chrono::duration<Value, std::ratio<1>>>
+  {
+    static std::string convert(std::chrono::duration<Value, std::ratio<1>> const &duration)
+    {
+      ReusableStringStream rss;
+      rss << duration.count() << " s";
+      return rss.str();
+    }
+  };
+  template <typename Value> struct StringMaker<std::chrono::duration<Value, std::ratio<60>>>
+  {
+    static std::string convert(std::chrono::duration<Value, std::ratio<60>> const &duration)
+    {
+      ReusableStringStream rss;
+      rss << duration.count() << " m";
+      return rss.str();
+    }
+  };
+  template <typename Value> struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>>
+  {
+    static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const &duration)
+    {
+      ReusableStringStream rss;
+      rss << duration.count() << " h";
+      return rss.str();
+    }
+  };
+
+  ////////////
+  // std::chrono::time_point specialization
+  // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+  template <typename Clock, typename Duration>
+  struct StringMaker<std::chrono::time_point<Clock, Duration>>
+  {
+    static std::string convert(std::chrono::time_point<Clock, Duration> const &time_point)
+    {
+      return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+    }
+  };
+  // std::chrono::time_point<system_clock> specialization
+  template <typename Duration>
+  struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>>
+  {
+    static std::string
+    convert(std::chrono::time_point<std::chrono::system_clock, Duration> const &time_point)
+    {
+      auto converted = std::chrono::system_clock::to_time_t(time_point);
 
 #ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
+      std::tm timeInfo = {};
+      gmtime_s(&timeInfo, &converted);
 #else
-            std::tm* timeInfo = std::gmtime(&converted);
+      std::tm *timeInfo = std::gmtime(&converted);
 #endif
 
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+      auto const        timeStampSize = sizeof("2017-01-16T17:06:45Z");
+      char              timeStamp[timeStampSize];
+      const char *const fmt = "%Y-%m-%dT%H:%M:%SZ";
 
 #ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+      std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
 #else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+      std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
 #endif
-            return std::string(timeStamp);
-        }
-    };
-}
+      return std::string(timeStamp);
+    }
+  };
+} // namespace Catch
 #endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
 
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return enumInfo.lookup( static_cast<int>( value ) ); \
-        } \
-    }; \
-}
+#define INTERNAL_CATCH_REGISTER_ENUM(enumName, ...)                                                \
+  namespace Catch {                                                                                \
+    template <> struct StringMaker<enumName>                                                       \
+    {                                                                                              \
+      static std::string convert(enumName value)                                                   \
+      {                                                                                            \
+        static const auto &enumInfo =                                                              \
+            ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum(          \
+                #enumName, #__VA_ARGS__, {__VA_ARGS__});                                           \
+        return static_cast<std::string>(enumInfo.lookup(static_cast<int>(value)));                 \
+      }                                                                                            \
+    };                                                                                             \
+  }
 
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+#define CATCH_REGISTER_ENUM(enumName, ...) INTERNAL_CATCH_REGISTER_ENUM(enumName, __VA_ARGS__)
 
 #ifdef _MSC_VER
 #pragma warning(pop)
@@ -2160,225 +2607,252 @@ namespace Catch { \
 
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
+#pragma warning(disable : 4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable : 4018) // more "signed/unsigned mismatch"
+#pragma warning(                                                                                   \
+    disable : 4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable : 4180) // qualifier applied to function type has no meaning
+#pragma warning(disable : 4800) // Forcing result to true or false
 #endif
 
 namespace Catch {
 
-    struct ITransientExpression {
-        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        auto getResult() const -> bool { return m_result; }
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+  struct ITransientExpression
+  {
+    auto         isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+    auto         getResult() const -> bool { return m_result; }
+    virtual void streamReconstructedExpression(std::ostream &os) const = 0;
 
-        ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
+    ITransientExpression(bool isBinaryExpression, bool result)
+        : m_isBinaryExpression(isBinaryExpression), m_result(result)
+    {
+    }
 
-        // We don't actually need a virtual destructor, but many static analyzers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
+    // We don't actually need a virtual destructor, but many static analysers
+    // complain if it's not here :-(
+    virtual ~ITransientExpression();
 
-        bool m_isBinaryExpression;
-        bool m_result;
+    bool m_isBinaryExpression;
+    bool m_result;
+  };
 
-    };
+  void formatReconstructedExpression(std::ostream &os, std::string const &lhs, StringRef op,
+                                     std::string const &rhs);
 
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+  template <typename LhsT, typename RhsT> class BinaryExpr : public ITransientExpression
+  {
+    LhsT      m_lhs;
+    StringRef m_op;
+    RhsT      m_rhs;
 
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
+    void streamReconstructedExpression(std::ostream &os) const override
+    {
+      formatReconstructedExpression(os, Catch::Detail::stringify(m_lhs), m_op,
+                                    Catch::Detail::stringify(m_rhs));
+    }
 
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
+  public:
+    BinaryExpr(bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs)
+        : ITransientExpression{true, comparisonResult}, m_lhs(lhs), m_op(op), m_rhs(rhs)
+    {
+    }
 
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator&&(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator||(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator==(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator!=(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator>(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator<(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename T> auto operator>=(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
+    template <typename T> auto operator<=(T) const -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<T>::value,
+                    "chained comparisons are not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
+  };
 
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
+  template <typename LhsT> class UnaryExpr : public ITransientExpression
+  {
+    LhsT m_lhs;
 
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
+    void streamReconstructedExpression(std::ostream &os) const override
+    {
+      os << Catch::Detail::stringify(m_lhs);
+    }
 
-    public:
-        explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
+  public:
+    explicit UnaryExpr(LhsT lhs) : ITransientExpression{false, static_cast<bool>(lhs)}, m_lhs(lhs)
+    {
+    }
+  };
 
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+  // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL
+  // deduces as an int)
+  template <typename LhsT, typename RhsT>
+  auto compareEqual(LhsT const &lhs, RhsT const &rhs) -> bool
+  {
+    return static_cast<bool>(lhs == rhs);
+  }
+  template <typename T> auto compareEqual(T *const &lhs, int rhs) -> bool
+  {
+    return lhs == reinterpret_cast<void const *>(rhs);
+  }
+  template <typename T> auto compareEqual(T *const &lhs, long rhs) -> bool
+  {
+    return lhs == reinterpret_cast<void const *>(rhs);
+  }
+  template <typename T> auto compareEqual(int lhs, T *const &rhs) -> bool
+  {
+    return reinterpret_cast<void const *>(lhs) == rhs;
+  }
+  template <typename T> auto compareEqual(long lhs, T *const &rhs) -> bool
+  {
+    return reinterpret_cast<void const *>(lhs) == rhs;
+  }
 
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "==", rhs };
-        }
+  template <typename LhsT, typename RhsT> auto compareNotEqual(LhsT const &lhs, RhsT &&rhs) -> bool
+  {
+    return static_cast<bool>(lhs != rhs);
+  }
+  template <typename T> auto compareNotEqual(T *const &lhs, int rhs) -> bool
+  {
+    return lhs != reinterpret_cast<void const *>(rhs);
+  }
+  template <typename T> auto compareNotEqual(T *const &lhs, long rhs) -> bool
+  {
+    return lhs != reinterpret_cast<void const *>(rhs);
+  }
+  template <typename T> auto compareNotEqual(int lhs, T *const &rhs) -> bool
+  {
+    return reinterpret_cast<void const *>(lhs) != rhs;
+  }
+  template <typename T> auto compareNotEqual(long lhs, T *const &rhs) -> bool
+  {
+    return reinterpret_cast<void const *>(lhs) != rhs;
+  }
 
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!=", rhs };
-        }
+  template <typename LhsT> class ExprLhs
+  {
+    LhsT m_lhs;
 
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
-        }
+  public:
+    explicit ExprLhs(LhsT lhs) : m_lhs(lhs) {}
 
-        template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename RhsT>
+    auto operator==(RhsT const &rhs) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      return {compareEqual(m_lhs, rhs), m_lhs, "==", rhs};
+    }
+    auto operator==(bool rhs) -> BinaryExpr<LhsT, bool> const
+    {
+      return {m_lhs == rhs, m_lhs, "==", rhs};
+    }
 
-        template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
+    template <typename RhsT>
+    auto operator!=(RhsT const &rhs) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      return {compareNotEqual(m_lhs, rhs), m_lhs, "!=", rhs};
+    }
+    auto operator!=(bool rhs) -> BinaryExpr<LhsT, bool> const
+    {
+      return {m_lhs != rhs, m_lhs, "!=", rhs};
+    }
 
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
+    template <typename RhsT> auto operator>(RhsT const &rhs) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      return {static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs};
+    }
+    template <typename RhsT> auto operator<(RhsT const &rhs) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      return {static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs};
+    }
+    template <typename RhsT>
+    auto operator>=(RhsT const &rhs) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      return {static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs};
+    }
+    template <typename RhsT>
+    auto operator<=(RhsT const &rhs) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      return {static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs};
+    }
 
-    void handleExpression( ITransientExpression const& expr );
+    template <typename RhsT> auto operator&&(RhsT const &) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<RhsT>::value,
+                    "operator&& is not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
+    }
 
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
+    template <typename RhsT> auto operator||(RhsT const &) -> BinaryExpr<LhsT, RhsT const &> const
+    {
+      static_assert(always_false<RhsT>::value,
+                    "operator|| is not supported inside assertions, "
+                    "wrap the expression inside parentheses, or decompose it");
     }
 
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
-        }
+    auto makeUnaryExpr() const -> UnaryExpr<LhsT> { return UnaryExpr<LhsT>{m_lhs}; }
+  };
 
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
-        }
-    };
+  void handleExpression(ITransientExpression const &expr);
+
+  template <typename T> void handleExpression(ExprLhs<T> const &expr)
+  {
+    handleExpression(expr.makeUnaryExpr());
+  }
+
+  struct Decomposer
+  {
+    template <typename T> auto operator<=(T const &lhs) -> ExprLhs<T const &>
+    {
+      return ExprLhs<T const &>{lhs};
+    }
+
+    auto operator<=(bool value) -> ExprLhs<bool> { return ExprLhs<bool>{value}; }
+  };
 
 } // end namespace Catch
 
@@ -2389,160 +2863,154 @@ namespace Catch {
 // end catch_decomposer.h
 // start catch_interfaces_capture.h
 
-#include <string>
 #include <chrono>
+#include <string>
 
 namespace Catch {
 
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
+  class AssertionResult;
+  struct AssertionInfo;
+  struct SectionInfo;
+  struct SectionEndInfo;
+  struct MessageInfo;
+  struct MessageBuilder;
+  struct Counts;
+  struct AssertionReaction;
+  struct SourceLineInfo;
 
-    struct ITransientExpression;
-    struct IGeneratorTracker;
+  struct ITransientExpression;
+  struct IGeneratorTracker;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo;
-    template <typename Duration = std::chrono::duration<double, std::nano>>
-    struct BenchmarkStats;
+  struct BenchmarkInfo;
+  template <typename Duration = std::chrono::duration<double, std::nano>> struct BenchmarkStats;
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    struct IResultCapture {
+  struct IResultCapture
+  {
 
-        virtual ~IResultCapture();
+    virtual ~IResultCapture();
 
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+    virtual bool sectionStarted(SectionInfo const &sectionInfo, Counts &assertions) = 0;
+    virtual void sectionEnded(SectionEndInfo const &endInfo)                        = 0;
+    virtual void sectionEndedEarly(SectionEndInfo const &endInfo)                   = 0;
 
-        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+    virtual auto acquireGeneratorTracker(SourceLineInfo const &lineInfo) -> IGeneratorTracker & = 0;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( std::string const& error ) = 0;
+    virtual void benchmarkPreparing(std::string const &name)   = 0;
+    virtual void benchmarkStarting(BenchmarkInfo const &info)  = 0;
+    virtual void benchmarkEnded(BenchmarkStats<> const &stats) = 0;
+    virtual void benchmarkFailed(std::string const &error)     = 0;
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
+    virtual void pushScopedMessage(MessageInfo const &message) = 0;
+    virtual void popScopedMessage(MessageInfo const &message)  = 0;
 
-    IResultCapture& getResultCapture();
-}
+    virtual void emplaceUnscopedMessage(MessageBuilder const &builder) = 0;
 
-// end catch_interfaces_capture.h
-namespace Catch {
+    virtual void handleFatalErrorCondition(StringRef message) = 0;
 
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
+    virtual void handleExpr(AssertionInfo const &info, ITransientExpression const &expr,
+                            AssertionReaction &reaction)                              = 0;
+    virtual void handleMessage(AssertionInfo const &info, ResultWas::OfType resultType,
+                               StringRef const &message, AssertionReaction &reaction) = 0;
+    virtual void handleUnexpectedExceptionNotThrown(AssertionInfo const &info,
+                                                    AssertionReaction &  reaction)      = 0;
+    virtual void handleUnexpectedInflightException(AssertionInfo const &info,
+                                                   std::string const &  message,
+                                                   AssertionReaction &  reaction)       = 0;
+    virtual void handleIncomplete(AssertionInfo const &info)                          = 0;
+    virtual void handleNonExpr(AssertionInfo const &info, ResultWas::OfType resultType,
+                               AssertionReaction &reaction)                           = 0;
 
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
+    virtual bool lastAssertionPassed() = 0;
+    virtual void assertionPassed()     = 0;
 
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
+    // Deprecated, do not use:
+    virtual std::string            getCurrentTestName() const = 0;
+    virtual const AssertionResult *getLastResult() const      = 0;
+    virtual void                   exceptionEarlyReported()   = 0;
+  };
 
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
+  IResultCapture &getResultCapture();
+} // namespace Catch
 
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
+// end catch_interfaces_capture.h
+namespace Catch {
 
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
+  struct TestFailureException
+  {
+  };
+  struct AssertionResultData;
+  struct IResultCapture;
+  class RunContext;
+
+  class LazyExpression
+  {
+    friend class AssertionHandler;
+    friend struct AssertionStats;
+    friend class RunContext;
+
+    ITransientExpression const *m_transientExpression = nullptr;
+    bool                        m_isNegated;
+
+  public:
+    LazyExpression(bool isNegated);
+    LazyExpression(LazyExpression const &other);
+    LazyExpression &operator=(LazyExpression const &) = delete;
+
+    explicit operator bool() const;
+
+    friend auto operator<<(std::ostream &os, LazyExpression const &lazyExpr) -> std::ostream &;
+  };
+
+  struct AssertionReaction
+  {
+    bool shouldDebugBreak = false;
+    bool shouldThrow      = false;
+  };
+
+  class AssertionHandler
+  {
+    AssertionInfo     m_assertionInfo;
+    AssertionReaction m_reaction;
+    bool              m_completed = false;
+    IResultCapture &  m_resultCapture;
+
+  public:
+    AssertionHandler(StringRef const &macroName, SourceLineInfo const &lineInfo,
+                     StringRef capturedExpression, ResultDisposition::Flags resultDisposition);
+    ~AssertionHandler()
+    {
+      if (!m_completed) {
+        m_resultCapture.handleIncomplete(m_assertionInfo);
+      }
+    }
 
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
+    template <typename T> void handleExpr(ExprLhs<T> const &expr)
+    {
+      handleExpr(expr.makeUnaryExpr());
+    }
+    void handleExpr(ITransientExpression const &expr);
 
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+    void handleMessage(ResultWas::OfType resultType, StringRef const &message);
 
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
+    void handleExceptionThrownAsExpected();
+    void handleUnexpectedExceptionNotThrown();
+    void handleExceptionNotThrownAsExpected();
+    void handleThrowingCallSkipped();
+    void handleUnexpectedInflightException();
 
-        void complete();
-        void setCompleted();
+    void complete();
+    void setCompleted();
 
-        // query
-        auto allowThrows() const -> bool;
-    };
+    // query
+    auto allowThrows() const -> bool;
+  };
 
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
+  void handleExceptionMatchExpr(AssertionHandler &handler, std::string const &str,
+                                StringRef const &matcherString);
 
 } // namespace Catch
 
@@ -2554,80 +3022,87 @@ namespace Catch {
 
 namespace Catch {
 
-    struct MessageInfo {
-        MessageInfo(    StringRef const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
+  struct MessageInfo
+  {
+    MessageInfo(StringRef const &_macroName, SourceLineInfo const &_lineInfo,
+                ResultWas::OfType _type);
 
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
+    StringRef         macroName;
+    std::string       message;
+    SourceLineInfo    lineInfo;
+    ResultWas::OfType type;
+    unsigned int      sequence;
 
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
+    bool operator==(MessageInfo const &other) const;
+    bool operator<(MessageInfo const &other) const;
 
-    struct MessageStream {
+  private:
+    static unsigned int globalCount;
+  };
 
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
+  struct MessageStream
+  {
 
-        ReusableStringStream m_stream;
-    };
+    template <typename T> MessageStream &operator<<(T const &value)
+    {
+      m_stream << value;
+      return *this;
+    }
 
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
+    ReusableStringStream m_stream;
+  };
 
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
+  struct MessageBuilder : MessageStream
+  {
+    MessageBuilder(StringRef const &macroName, SourceLineInfo const &lineInfo,
+                   ResultWas::OfType type);
 
-        MessageInfo m_info;
-    };
+    template <typename T> MessageBuilder &operator<<(T const &value)
+    {
+      m_stream << value;
+      return *this;
+    }
 
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old );
-        ~ScopedMessage();
+    MessageInfo m_info;
+  };
 
-        MessageInfo m_info;
-        bool m_moved;
-    };
+  class ScopedMessage
+  {
+  public:
+    explicit ScopedMessage(MessageBuilder const &builder);
+    ScopedMessage(ScopedMessage &duplicate) = delete;
+    ScopedMessage(ScopedMessage &&old);
+    ~ScopedMessage();
 
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-        ~Capturer();
+    MessageInfo m_info;
+    bool        m_moved;
+  };
 
-        void captureValue( size_t index, std::string const& value );
+  class Capturer
+  {
+    std::vector<MessageInfo> m_messages;
+    IResultCapture &         m_resultCapture = getResultCapture();
+    size_t                   m_captured      = 0;
 
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
+  public:
+    Capturer(StringRef macroName, SourceLineInfo const &lineInfo, ResultWas::OfType resultType,
+             StringRef names);
+    ~Capturer();
 
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
+    void captureValue(size_t index, std::string const &value);
+
+    template <typename T> void captureValues(size_t index, T const &value)
+    {
+      captureValue(index, Catch::Detail::stringify(value));
+    }
+
+    template <typename T, typename... Ts>
+    void captureValues(size_t index, T const &value, Ts const &... values)
+    {
+      captureValue(index, Catch::Detail::stringify(value));
+      captureValues(index + 1, values...);
+    }
+  };
 
 } // end namespace Catch
 
@@ -2635,9 +3110,9 @@ namespace Catch {
 #if !defined(CATCH_CONFIG_DISABLE)
 
 #if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
 #else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
 #endif
 
 #if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
@@ -2646,129 +3121,156 @@ namespace Catch {
 // Another way to speed-up compilation is to omit local try-catch for REQUIRE*
 // macros.
 #define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
+#define INTERNAL_CATCH_CATCH(capturer)
 
 #else // CATCH_CONFIG_FAST_COMPILE
 
 #define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
+#define INTERNAL_CATCH_CATCH(handler)                                                              \
+  catch (...) { handler.handleUnexpectedInflightException(); }
 
 #endif
 
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+#define INTERNAL_CATCH_REACT(handler) handler.complete();
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
-    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+#define INTERNAL_CATCH_TEST(macroName, resultDisposition, ...)                                     \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,   \
+                                                  CATCH_INTERNAL_STRINGIFY(__VA_ARGS__),           \
+                                                  resultDisposition);                              \
+    INTERNAL_CATCH_TRY                                                                             \
+    {                                                                                              \
+      CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS                                                 \
+      catchAssertionHandler.handleExpr(Catch::Decomposer() <= __VA_ARGS__);                        \
+      CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS                                               \
+    }                                                                                              \
+    INTERNAL_CATCH_CATCH(catchAssertionHandler)                                                    \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while ((void)0,                                                                                \
+           (false) && static_cast<bool>(                                                           \
+                          !!(__VA_ARGS__))) // the expression here is never evaluated at runtime but
+                                            // it forces the compiler to give it a look
+  // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit
+  // evaluation if the type has overloaded &&.
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
+#define INTERNAL_CATCH_IF(macroName, resultDisposition, ...)                                       \
+  INTERNAL_CATCH_TEST(macroName, resultDisposition, __VA_ARGS__);                                  \
+  if (Catch::getResultCapture().lastAssertionPassed())
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
+#define INTERNAL_CATCH_ELSE(macroName, resultDisposition, ...)                                     \
+  INTERNAL_CATCH_TEST(macroName, resultDisposition, __VA_ARGS__);                                  \
+  if (!Catch::getResultCapture().lastAssertionPassed())
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CATCH_NO_THROW(macroName, resultDisposition, ...)                                 \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,   \
+                                                  CATCH_INTERNAL_STRINGIFY(__VA_ARGS__),           \
+                                                  resultDisposition);                              \
+    try {                                                                                          \
+      static_cast<void>(__VA_ARGS__);                                                              \
+      catchAssertionHandler.handleExceptionNotThrownAsExpected();                                  \
+    }                                                                                              \
+    catch (...) {                                                                                  \
+      catchAssertionHandler.handleUnexpectedInflightException();                                   \
+    }                                                                                              \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CATCH_THROWS(macroName, resultDisposition, ...)                                   \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,   \
+                                                  CATCH_INTERNAL_STRINGIFY(__VA_ARGS__),           \
+                                                  resultDisposition);                              \
+    if (catchAssertionHandler.allowThrows())                                                       \
+      try {                                                                                        \
+        static_cast<void>(__VA_ARGS__);                                                            \
+        catchAssertionHandler.handleUnexpectedExceptionNotThrown();                                \
+      }                                                                                            \
+      catch (...) {                                                                                \
+        catchAssertionHandler.handleExceptionThrownAsExpected();                                   \
+      }                                                                                            \
+    else                                                                                           \
+      catchAssertionHandler.handleThrowingCallSkipped();                                           \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CATCH_THROWS_AS(macroName, exceptionType, resultDisposition, expr)                \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(                                                 \
+        macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,                                             \
+        CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType),               \
+        resultDisposition);                                                                        \
+    if (catchAssertionHandler.allowThrows())                                                       \
+      try {                                                                                        \
+        static_cast<void>(expr);                                                                   \
+        catchAssertionHandler.handleUnexpectedExceptionNotThrown();                                \
+      }                                                                                            \
+      catch (exceptionType const &) {                                                              \
+        catchAssertionHandler.handleExceptionThrownAsExpected();                                   \
+      }                                                                                            \
+      catch (...) {                                                                                \
+        catchAssertionHandler.handleUnexpectedInflightException();                                 \
+      }                                                                                            \
+    else                                                                                           \
+      catchAssertionHandler.handleThrowingCallSkipped();                                           \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CATCH_MSG(macroName, messageType, resultDisposition, ...)                         \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,   \
+                                                  Catch::StringRef(), resultDisposition);          \
+    catchAssertionHandler.handleMessage(                                                           \
+        messageType,                                                                               \
+        (Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop()).m_stream.str());        \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
+#define INTERNAL_CATCH_CAPTURE(varName, macroName, ...)                                            \
+  auto varName =                                                                                   \
+      Catch::Capturer(macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__);   \
+  varName.captureValues(0, __VA_ARGS__)
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+#define INTERNAL_CATCH_INFO(macroName, log)                                                        \
+  Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME(scopedMessage)(                                  \
+      Catch::MessageBuilder(macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info) \
+      << log);
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+#define INTERNAL_CATCH_UNSCOPED_INFO(macroName, log)                                               \
+  Catch::getResultCapture().emplaceUnscopedMessage(                                                \
+      Catch::MessageBuilder(macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info) \
+      << log)
 
 ///////////////////////////////////////////////////////////////////////////////
 // Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CATCH_THROWS_STR_MATCHES(macroName, resultDisposition, matcher, ...)              \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(                                                 \
+        macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,                                             \
+        CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher),              \
+        resultDisposition);                                                                        \
+    if (catchAssertionHandler.allowThrows())                                                       \
+      try {                                                                                        \
+        static_cast<void>(__VA_ARGS__);                                                            \
+        catchAssertionHandler.handleUnexpectedExceptionNotThrown();                                \
+      }                                                                                            \
+      catch (...) {                                                                                \
+        Catch::handleExceptionMatchExpr(catchAssertionHandler, matcher, #matcher##_catch_sr);      \
+      }                                                                                            \
+    else                                                                                           \
+      catchAssertionHandler.handleThrowingCallSkipped();                                           \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 #endif // CATCH_CONFIG_DISABLE
 
@@ -2783,58 +3285,60 @@ namespace Catch {
 
 namespace Catch {
 
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
+  struct Counts
+  {
+    Counts  operator-(Counts const &other) const;
+    Counts &operator+=(Counts const &other);
 
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
+    std::size_t total() const;
+    bool        allPassed() const;
+    bool        allOk() const;
 
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
+    std::size_t passed      = 0;
+    std::size_t failed      = 0;
+    std::size_t failedButOk = 0;
+  };
 
-    struct Totals {
+  struct Totals
+  {
 
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
+    Totals  operator-(Totals const &other) const;
+    Totals &operator+=(Totals const &other);
 
-        Totals delta( Totals const& prevTotals ) const;
+    Totals delta(Totals const &prevTotals) const;
 
-        int error = 0;
-        Counts assertions;
-        Counts testCases;
-    };
-}
+    int    error = 0;
+    Counts assertions;
+    Counts testCases;
+  };
+} // namespace Catch
 
 // end catch_totals.h
 #include <string>
 
 namespace Catch {
 
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name );
+  struct SectionInfo
+  {
+    SectionInfo(SourceLineInfo const &_lineInfo, std::string const &_name);
 
-        // Deprecated
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
+    // Deprecated
+    SectionInfo(SourceLineInfo const &_lineInfo, std::string const &_name, std::string const &)
+        : SectionInfo(_lineInfo, _name)
+    {
+    }
 
-        std::string name;
-        std::string description; // !Deprecated: this will always be empty
-        SourceLineInfo lineInfo;
-    };
+    std::string    name;
+    std::string    description; // !Deprecated: this will always be empty
+    SourceLineInfo lineInfo;
+  };
 
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
+  struct SectionEndInfo
+  {
+    SectionInfo sectionInfo;
+    Counts      prevAssertions;
+    double      durationInSeconds;
+  };
 
 } // end namespace Catch
 
@@ -2845,18 +3349,20 @@ namespace Catch {
 
 namespace Catch {
 
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
+  auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+  auto getEstimatedClockResolution() -> uint64_t;
 
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
+  class Timer
+  {
+    uint64_t m_nanoseconds = 0;
+
+  public:
+    void start();
+    auto getElapsedNanoseconds() const -> uint64_t;
+    auto getElapsedMicroseconds() const -> uint64_t;
+    auto getElapsedMilliseconds() const -> unsigned int;
+    auto getElapsedSeconds() const -> double;
+  };
 
 } // namespace Catch
 
@@ -2865,91 +3371,98 @@ namespace Catch {
 
 namespace Catch {
 
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
+  class Section : NonCopyable
+  {
+  public:
+    Section(SectionInfo const &info);
+    ~Section();
 
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
+    // This indicates whether the section should be executed or not
+    explicit operator bool() const;
 
-    private:
-        SectionInfo m_info;
+  private:
+    SectionInfo m_info;
 
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
+    std::string m_name;
+    Counts      m_assertions;
+    bool        m_sectionIncluded;
+    Timer       m_timer;
+  };
 
 } // end namespace Catch
 
-#define INTERNAL_CATCH_SECTION( ... ) \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-    CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
+#define INTERNAL_CATCH_SECTION(...)                                                                \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS                                                          \
+  if (Catch::Section const &INTERNAL_CATCH_UNIQUE_NAME(catch_internal_Section) =                   \
+          Catch::SectionInfo(CATCH_INTERNAL_LINEINFO, __VA_ARGS__))                                \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
-    CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
+#define INTERNAL_CATCH_DYNAMIC_SECTION(...)                                                        \
+  CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS                                                          \
+  if (Catch::Section const &INTERNAL_CATCH_UNIQUE_NAME(catch_internal_Section) =                   \
+          Catch::SectionInfo(CATCH_INTERNAL_LINEINFO,                                              \
+                             (Catch::ReusableStringStream() << __VA_ARGS__).str()))                \
+  CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 
 // end catch_section.h
 // start catch_interfaces_exception.h
 
 // start catch_interfaces_registry_hub.h
 
-#include <string>
 #include <memory>
+#include <string>
 
 namespace Catch {
 
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    struct IMutableEnumValuesRegistry;
-
-    class StartupExceptionRegistry;
-
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+  class TestCase;
+  struct ITestCaseRegistry;
+  struct IExceptionTranslatorRegistry;
+  struct IExceptionTranslator;
+  struct IReporterRegistry;
+  struct IReporterFactory;
+  struct ITagAliasRegistry;
+  struct IMutableEnumValuesRegistry;
+
+  class StartupExceptionRegistry;
+
+  using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+  struct IRegistryHub
+  {
+    virtual ~IRegistryHub();
+
+    virtual IReporterRegistry const &           getReporterRegistry() const            = 0;
+    virtual ITestCaseRegistry const &           getTestCaseRegistry() const            = 0;
+    virtual ITagAliasRegistry const &           getTagAliasRegistry() const            = 0;
+    virtual IExceptionTranslatorRegistry const &getExceptionTranslatorRegistry() const = 0;
+
+    virtual StartupExceptionRegistry const &getStartupExceptionRegistry() const = 0;
+  };
+
+  struct IMutableRegistryHub
+  {
+    virtual ~IMutableRegistryHub();
+    virtual void registerReporter(std::string const &name, IReporterFactoryPtr const &factory) = 0;
+    virtual void registerListener(IReporterFactoryPtr const &factory)                          = 0;
+    virtual void registerTest(TestCase const &testInfo)                                        = 0;
+    virtual void registerTranslator(const IExceptionTranslator *translator)                    = 0;
+    virtual void registerTagAlias(std::string const &alias, std::string const &tag,
+                                  SourceLineInfo const &lineInfo)                              = 0;
+    virtual void registerStartupException() noexcept                                           = 0;
+    virtual IMutableEnumValuesRegistry &getMutableEnumValuesRegistry()                         = 0;
+  };
+
+  IRegistryHub const & getRegistryHub();
+  IMutableRegistryHub &getMutableRegistryHub();
+  void                 cleanUp();
+  std::string          translateActiveException();
 
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
+} // namespace Catch
 
 // end catch_interfaces_registry_hub.h
 #if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-        static std::string translatorName( signature )
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG(translatorName, signature)                       \
+  static std::string translatorName(signature)
 #endif
 
 #include <exception>
@@ -2957,65 +3470,75 @@ namespace Catch {
 #include <vector>
 
 namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
+  using exceptionTranslateFunction = std::string (*)();
 
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
+  struct IExceptionTranslator;
+  using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
 
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
+  struct IExceptionTranslator
+  {
+    virtual ~IExceptionTranslator();
+    virtual std::string translate(ExceptionTranslators::const_iterator it,
+                                  ExceptionTranslators::const_iterator itEnd) const = 0;
+  };
 
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
+  struct IExceptionTranslatorRegistry
+  {
+    virtual ~IExceptionTranslatorRegistry();
 
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
+    virtual std::string translateActiveException() const = 0;
+  };
 
+  class ExceptionTranslatorRegistrar
+  {
+    template <typename T> class ExceptionTranslator : public IExceptionTranslator
+    {
     public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
+      ExceptionTranslator(std::string (*translateFunction)(T &))
+          : m_translateFunction(translateFunction)
+      {
+      }
+
+      std::string translate(ExceptionTranslators::const_iterator it,
+                            ExceptionTranslators::const_iterator itEnd) const override
+      {
+        try {
+          if (it == itEnd)
+            std::rethrow_exception(std::current_exception());
+          else
+            return (*it)->translate(it + 1, itEnd);
         }
+        catch (T &ex) {
+          return m_translateFunction(ex);
+        }
+      }
+
+    protected:
+      std::string (*m_translateFunction)(T &);
     };
-}
 
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-    static std::string translatorName( signature )
+  public:
+    template <typename T> ExceptionTranslatorRegistrar(std::string (*translateFunction)(T &))
+    {
+      getMutableRegistryHub().registerTranslator(new ExceptionTranslator<T>(translateFunction));
+    }
+  };
+} // namespace Catch
 
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2(translatorName, signature)                             \
+  static std::string translatorName(signature);                                                    \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    Catch::ExceptionTranslatorRegistrar                                                            \
+        INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionRegistrar)(&translatorName);            \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                                                       \
+  static std::string translatorName(signature)
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION(signature)                                              \
+  INTERNAL_CATCH_TRANSLATE_EXCEPTION2(                                                             \
+      INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionTranslator), signature)
 
 // end catch_interfaces_exception.h
 // start catch_approx.h
@@ -3023,152 +3546,184 @@ namespace Catch {
 #include <type_traits>
 
 namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
+  namespace Detail {
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
+    class Approx
+    {
+    private:
+      bool equalityComparisonImpl(double other) const;
+      // Validates the new margin (margin >= 0)
+      // out-of-line to avoid including stdexcept in the header
+      void setMargin(double margin);
+      // Validates the new epsilon (0 < epsilon < 1)
+      // out-of-line to avoid including stdexcept in the header
+      void setEpsilon(double epsilon);
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
+    public:
+      explicit Approx(double value);
+
+      static Approx custom();
+
+      Approx operator-() const;
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      Approx operator()(T const &value)
+      {
+        Approx approx(static_cast<double>(value));
+        approx.m_epsilon = m_epsilon;
+        approx.m_margin  = m_margin;
+        approx.m_scale   = m_scale;
+        return approx;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      explicit Approx(T const &value) : Approx(static_cast<double>(value))
+      {
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator==(const T &lhs, Approx const &rhs)
+      {
+        auto lhs_v = static_cast<double>(lhs);
+        return rhs.equalityComparisonImpl(lhs_v);
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator==(Approx const &lhs, const T &rhs)
+      {
+        return operator==(rhs, lhs);
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator!=(T const &lhs, Approx const &rhs)
+      {
+        return !operator==(lhs, rhs);
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator!=(Approx const &lhs, T const &rhs)
+      {
+        return !operator==(rhs, lhs);
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator<=(T const &lhs, Approx const &rhs)
+      {
+        return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator<=(Approx const &lhs, T const &rhs)
+      {
+        return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator>=(T const &lhs, Approx const &rhs)
+      {
+        return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      friend bool operator>=(Approx const &lhs, T const &rhs)
+      {
+        return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      Approx &epsilon(T const &newEpsilon)
+      {
+        double epsilonAsDouble = static_cast<double>(newEpsilon);
+        setEpsilon(epsilonAsDouble);
+        return *this;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      Approx &margin(T const &newMargin)
+      {
+        double marginAsDouble = static_cast<double>(newMargin);
+        setMargin(marginAsDouble);
+        return *this;
+      }
+
+      template <typename T,
+                typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+      Approx &scale(T const &newScale)
+      {
+        m_scale = static_cast<double>(newScale);
+        return *this;
+      }
 
-        std::string toString() const;
+      std::string toString() const;
 
     private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
+      double m_epsilon;
+      double m_margin;
+      double m_scale;
+      double m_value;
     };
-} // end namespace Detail
+  } // end namespace Detail
 
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
+  namespace literals {
+    Detail::Approx operator"" _a(long double val);
+    Detail::Approx operator"" _a(unsigned long long val);
+  } // end namespace literals
 
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
+  template <> struct StringMaker<Catch::Detail::Approx>
+  {
+    static std::string convert(Catch::Detail::Approx const &value);
+  };
 
 } // end namespace Catch
 
 // end catch_approx.h
 // start catch_string_manip.h
 
-#include <string>
 #include <iosfwd>
+#include <string>
 #include <vector>
 
 namespace Catch {
 
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    std::string trim( std::string const& str );
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-}
+  bool        startsWith(std::string const &s, std::string const &prefix);
+  bool        startsWith(std::string const &s, char prefix);
+  bool        endsWith(std::string const &s, std::string const &suffix);
+  bool        endsWith(std::string const &s, char suffix);
+  bool        contains(std::string const &s, std::string const &infix);
+  void        toLowerInPlace(std::string &s);
+  std::string toLower(std::string const &s);
+  //! Returns a new string without whitespace at the start/end
+  std::string trim(std::string const &str);
+  //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+  StringRef trim(StringRef ref);
+
+  // !!! Be aware, returns refs into original string - make sure original string outlives them
+  std::vector<StringRef> splitStringRef(StringRef str, char delimiter);
+  bool                   replaceInPlace(std::string &str, std::string const &replaceThis,
+                                        std::string const &withThis);
+
+  struct pluralise
+  {
+    pluralise(std::size_t count, std::string const &label);
+
+    friend std::ostream &operator<<(std::ostream &os, pluralise const &pluraliser);
+
+    std::size_t m_count;
+    std::string m_label;
+  };
+} // namespace Catch
 
 // end catch_string_manip.h
 #ifndef CATCH_CONFIG_DISABLE_MATCHERS
@@ -3180,201 +3735,258 @@ namespace Catch {
 #include <vector>
 
 namespace Catch {
-namespace Matchers {
+  namespace Matchers {
     namespace Impl {
 
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
+      template <typename ArgT> struct MatchAllOf;
+      template <typename ArgT> struct MatchAnyOf;
+      template <typename ArgT> struct MatchNotOf;
 
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
+      class MatcherUntypedBase
+      {
+      public:
+        MatcherUntypedBase()                           = default;
+        MatcherUntypedBase(MatcherUntypedBase const &) = default;
+        MatcherUntypedBase &operator=(MatcherUntypedBase const &) = delete;
+        std::string         toString() const;
+
+      protected:
+        virtual ~MatcherUntypedBase();
+        virtual std::string describe() const = 0;
+        mutable std::string m_cachedToString;
+      };
 
 #ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
 #endif
 
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
+      template <typename ObjectT> struct MatcherMethod
+      {
+        virtual bool match(ObjectT const &arg) const = 0;
+      };
 
 #if defined(__OBJC__)
-        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
-        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
-        template<>
-        struct MatcherMethod<NSString*> {
-            virtual bool match( NSString* arg ) const = 0;
-        };
+      // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+      // use of const for Object pointers is very uncommon and under ARC it causes some kind of
+      // signature mismatch that breaks compilation
+      template <> struct MatcherMethod<NSString *>
+      {
+        virtual bool match(NSString *arg) const = 0;
+      };
 #endif
 
 #ifdef __clang__
-#    pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #endif
 
-        template<typename T>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+      template <typename T> struct MatcherBase : MatcherUntypedBase, MatcherMethod<T>
+      {
 
-            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<T> operator ! () const;
-        };
+        MatchAllOf<T> operator&&(MatcherBase const &other) const;
+        MatchAnyOf<T> operator||(MatcherBase const &other) const;
+        MatchNotOf<T> operator!() const;
+      };
 
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
+      template <typename ArgT> struct MatchAllOf : MatcherBase<ArgT>
+      {
+        bool match(ArgT const &arg) const override
+        {
+          for (auto matcher : m_matchers) {
+            if (!matcher->match(arg))
+              return false;
+          }
+          return true;
+        }
+        std::string describe() const override
+        {
+          std::string description;
+          description.reserve(4 + m_matchers.size() * 32);
+          description += "( ";
+          bool first = true;
+          for (auto matcher : m_matchers) {
+            if (first)
+              first = false;
+            else
+              description += " and ";
+            description += matcher->toString();
+          }
+          description += " )";
+          return description;
+        }
 
-            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
+        MatchAllOf<ArgT> &operator&&(MatcherBase<ArgT> const &other)
+        {
+          m_matchers.push_back(&other);
+          return *this;
+        }
 
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
+        std::vector<MatcherBase<ArgT> const *> m_matchers;
+      };
+      template <typename ArgT> struct MatchAnyOf : MatcherBase<ArgT>
+      {
 
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
+        bool match(ArgT const &arg) const override
+        {
+          for (auto matcher : m_matchers) {
+            if (matcher->match(arg))
+              return true;
+          }
+          return false;
+        }
+        std::string describe() const override
+        {
+          std::string description;
+          description.reserve(4 + m_matchers.size() * 32);
+          description += "( ";
+          bool first = true;
+          for (auto matcher : m_matchers) {
+            if (first)
+              first = false;
+            else
+              description += " or ";
+            description += matcher->toString();
+          }
+          description += " )";
+          return description;
+        }
 
-            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
+        MatchAnyOf<ArgT> &operator||(MatcherBase<ArgT> const &other)
+        {
+          m_matchers.push_back(&other);
+          return *this;
+        }
 
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
+        std::vector<MatcherBase<ArgT> const *> m_matchers;
+      };
 
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
+      template <typename ArgT> struct MatchNotOf : MatcherBase<ArgT>
+      {
 
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+        MatchNotOf(MatcherBase<ArgT> const &underlyingMatcher)
+            : m_underlyingMatcher(underlyingMatcher)
+        {
+        }
 
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
+        bool match(ArgT const &arg) const override { return !m_underlyingMatcher.match(arg); }
 
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
+        std::string describe() const override { return "not " + m_underlyingMatcher.toString(); }
+        MatcherBase<ArgT> const &m_underlyingMatcher;
+      };
 
-        template<typename T>
-        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<T>() && *this && other;
-        }
-        template<typename T>
-        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<T>() || *this || other;
-        }
-        template<typename T>
-        MatchNotOf<T> MatcherBase<T>::operator ! () const {
-            return MatchNotOf<T>( *this );
-        }
+      template <typename T> MatchAllOf<T> MatcherBase<T>::operator&&(MatcherBase const &other) const
+      {
+        return MatchAllOf<T>() && *this && other;
+      }
+      template <typename T> MatchAnyOf<T> MatcherBase<T>::operator||(MatcherBase const &other) const
+      {
+        return MatchAnyOf<T>() || *this || other;
+      }
+      template <typename T> MatchNotOf<T> MatcherBase<T>::operator!() const
+      {
+        return MatchNotOf<T>(*this);
+      }
 
     } // namespace Impl
 
-} // namespace Matchers
+  } // namespace Matchers
 
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
+  using namespace Matchers;
+  using Matchers::Impl::MatcherBase;
 
 } // namespace Catch
 
 // end catch_matchers.h
-// start catch_matchers_floating.h
+// start catch_matchers_exception.hpp
 
-#include <type_traits>
-#include <cmath>
+namespace Catch {
+  namespace Matchers {
+    namespace Exception {
+
+      class ExceptionMessageMatcher : public MatcherBase<std::exception>
+      {
+        std::string m_message;
+
+      public:
+        ExceptionMessageMatcher(std::string const &message) : m_message(message) {}
+
+        bool match(std::exception const &ex) const override;
+
+        std::string describe() const override;
+      };
+
+    } // namespace Exception
+
+    Exception::ExceptionMessageMatcher Message(std::string const &message);
+
+  } // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
 
 namespace Catch {
-namespace Matchers {
+  namespace Matchers {
 
     namespace Floating {
 
-        enum class FloatingPointKind : uint8_t;
+      enum class FloatingPointKind : uint8_t;
 
-        struct WithinAbsMatcher : MatcherBase<double> {
-            WithinAbsMatcher(double target, double margin);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_margin;
-        };
+      struct WithinAbsMatcher : MatcherBase<double>
+      {
+        WithinAbsMatcher(double target, double margin);
+        bool        match(double const &matchee) const override;
+        std::string describe() const override;
 
-        struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            int m_ulps;
-            FloatingPointKind m_type;
-        };
+      private:
+        double m_target;
+        double m_margin;
+      };
+
+      struct WithinUlpsMatcher : MatcherBase<double>
+      {
+        WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
+        bool        match(double const &matchee) const override;
+        std::string describe() const override;
+
+      private:
+        double            m_target;
+        uint64_t          m_ulps;
+        FloatingPointKind m_type;
+      };
+
+      // Given IEEE-754 format for floats and doubles, we can assume
+      // that float -> double promotion is lossless. Given this, we can
+      // assume that if we do the standard relative comparison of
+      // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+      // the same result if we do this for floats, as if we do this for
+      // doubles that were promoted from floats.
+      struct WithinRelMatcher : MatcherBase<double>
+      {
+        WithinRelMatcher(double target, double epsilon);
+        bool        match(double const &matchee) const override;
+        std::string describe() const override;
+
+      private:
+        double m_target;
+        double m_epsilon;
+      };
 
     } // namespace Floating
 
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff);
-    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
-
-} // namespace Matchers
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    Floating::WithinAbsMatcher  WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher  WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
+
+  } // namespace Matchers
 } // namespace Catch
 
 // end catch_matchers_floating.h
@@ -3384,45 +3996,43 @@ namespace Matchers {
 #include <string>
 
 namespace Catch {
-namespace Matchers {
-namespace Generic {
+  namespace Matchers {
+    namespace Generic {
 
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-}
+      namespace Detail {
+        std::string finalizeDescription(const std::string &desc);
+      }
 
-template <typename T>
-class PredicateMatcher : public MatcherBase<T> {
-    std::function<bool(T const&)> m_predicate;
-    std::string m_description;
-public:
+      template <typename T> class PredicateMatcher : public MatcherBase<T>
+      {
+        std::function<bool(T const &)> m_predicate;
+        std::string                    m_description;
 
-    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
-        :m_predicate(std::move(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
+      public:
+        PredicateMatcher(std::function<bool(T const &)> const &elem, std::string const &descr)
+            : m_predicate(std::move(elem)), m_description(Detail::finalizeDescription(descr))
+        {
+        }
 
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
+        bool match(T const &item) const override { return m_predicate(item); }
 
-    std::string describe() const override {
-        return m_description;
-    }
-};
+        std::string describe() const override { return m_description; }
+      };
 
-} // namespace Generic
+    } // namespace Generic
 
     // The following functions create the actual matcher objects.
     // The user has to explicitly specify type to the function, because
     // inferring std::function<bool(T const&)> is hard (but possible) and
     // requires a lot of TMP.
-    template<typename T>
-    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
-        return Generic::PredicateMatcher<T>(predicate, description);
+    template <typename T>
+    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const &)> const &predicate,
+                                           std::string const &                   description = "")
+    {
+      return Generic::PredicateMatcher<T>(predicate, description);
     }
 
-} // namespace Matchers
+  } // namespace Matchers
 } // namespace Catch
 
 // end catch_matchers_generic.hpp
@@ -3431,67 +4041,78 @@ class PredicateMatcher : public MatcherBase<T> {
 #include <string>
 
 namespace Catch {
-namespace Matchers {
+  namespace Matchers {
 
     namespace StdString {
 
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
+      struct CasedString
+      {
+        CasedString(std::string const &str, CaseSensitive::Choice caseSensitivity);
+        std::string adjustString(std::string const &str) const;
+        std::string caseSensitivitySuffix() const;
 
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-        struct RegexMatcher : MatcherBase<std::string> {
-            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
-            bool match( std::string const& matchee ) const override;
-            std::string describe() const override;
-
-        private:
-            std::string m_regex;
-            CaseSensitive::Choice m_caseSensitivity;
-        };
+        CaseSensitive::Choice m_caseSensitivity;
+        std::string           m_str;
+      };
+
+      struct StringMatcherBase : MatcherBase<std::string>
+      {
+        StringMatcherBase(std::string const &operation, CasedString const &comparator);
+        std::string describe() const override;
+
+        CasedString m_comparator;
+        std::string m_operation;
+      };
+
+      struct EqualsMatcher : StringMatcherBase
+      {
+        EqualsMatcher(CasedString const &comparator);
+        bool match(std::string const &source) const override;
+      };
+      struct ContainsMatcher : StringMatcherBase
+      {
+        ContainsMatcher(CasedString const &comparator);
+        bool match(std::string const &source) const override;
+      };
+      struct StartsWithMatcher : StringMatcherBase
+      {
+        StartsWithMatcher(CasedString const &comparator);
+        bool match(std::string const &source) const override;
+      };
+      struct EndsWithMatcher : StringMatcherBase
+      {
+        EndsWithMatcher(CasedString const &comparator);
+        bool match(std::string const &source) const override;
+      };
+
+      struct RegexMatcher : MatcherBase<std::string>
+      {
+        RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity);
+        bool        match(std::string const &matchee) const override;
+        std::string describe() const override;
+
+      private:
+        std::string           m_regex;
+        CaseSensitive::Choice m_caseSensitivity;
+      };
 
     } // namespace StdString
 
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
 
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
+    StdString::EqualsMatcher   Equals(std::string const &   str,
+                                      CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes);
+    StdString::ContainsMatcher Contains(std::string const &   str,
+                                        CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes);
+    StdString::EndsWithMatcher EndsWith(std::string const &   str,
+                                        CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes);
+    StdString::StartsWithMatcher
+                            StartsWith(std::string const &str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes);
+    StdString::RegexMatcher Matches(std::string const &   regex,
+                                    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes);
+
+  } // namespace Matchers
 } // namespace Catch
 
 // end catch_matchers_string.h
@@ -3500,237 +4121,264 @@ namespace Matchers {
 #include <algorithm>
 
 namespace Catch {
-namespace Matchers {
+  namespace Matchers {
 
     namespace Vector {
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+      template <typename T> struct ContainsElementMatcher : MatcherBase<std::vector<T>>
+      {
 
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+        ContainsElementMatcher(T const &comparator) : m_comparator(comparator) {}
 
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
+        bool match(std::vector<T> const &v) const override
+        {
+          for (auto const &el : v) {
+            if (el == m_comparator) {
+              return true;
             }
+          }
+          return false;
+        }
 
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
+        std::string describe() const override
+        {
+          return "Contains: " + ::Catch::Detail::stringify(m_comparator);
+        }
 
-            T const& m_comparator;
-        };
+        T const &m_comparator;
+      };
 
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
+      template <typename T> struct ContainsMatcher : MatcherBase<std::vector<T>>
+      {
 
-            std::vector<T> const& m_comparator;
-        };
+        ContainsMatcher(std::vector<T> const &comparator) : m_comparator(comparator) {}
 
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
+        bool match(std::vector<T> const &v) const override
+        {
+          // !TBD: see note in EqualsMatcher
+          if (m_comparator.size() > v.size())
+            return false;
+          for (auto const &comparator : m_comparator) {
+            auto present = false;
+            for (const auto &el : v) {
+              if (el == comparator) {
+                present = true;
+                break;
+              }
             }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+            if (!present) {
+              return false;
             }
-            std::vector<T> const& m_comparator;
-        };
+          }
+          return true;
+        }
+        std::string describe() const override
+        {
+          return "Contains: " + ::Catch::Detail::stringify(m_comparator);
+        }
 
-        template<typename T>
-        struct ApproxMatcher : MatcherBase<std::vector<T>> {
+        std::vector<T> const &m_comparator;
+      };
 
-            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
+      template <typename T> struct EqualsMatcher : MatcherBase<std::vector<T>>
+      {
 
-            bool match(std::vector<T> const &v) const override {
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != approx(v[i]))
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& epsilon( T const& newEpsilon ) {
-                approx.epsilon(newEpsilon);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& margin( T const& newMargin ) {
-                approx.margin(newMargin);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& scale( T const& newScale ) {
-                approx.scale(newScale);
-                return *this;
-            }
+        EqualsMatcher(std::vector<T> const &comparator) : m_comparator(comparator) {}
 
-            std::vector<T> const& m_comparator;
-            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
-        };
+        bool match(std::vector<T> const &v) const override
+        {
+          // !TBD: This currently works if all elements can be compared using !=
+          // - a more general approach would be via a compare template that defaults
+          // to using !=. but could be specialised for, e.g. std::vector<T> etc
+          // - then just call that directly
+          if (m_comparator.size() != v.size())
+            return false;
+          for (std::size_t i = 0; i < v.size(); ++i)
+            if (m_comparator[i] != v[i])
+              return false;
+          return true;
+        }
+        std::string describe() const override
+        {
+          return "Equals: " + ::Catch::Detail::stringify(m_comparator);
+        }
+        std::vector<T> const &m_comparator;
+      };
 
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-            }
+      template <typename T> struct ApproxMatcher : MatcherBase<std::vector<T>>
+      {
 
-            std::string describe() const override {
-                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-            }
-        private:
-            std::vector<T> const& m_target;
-        };
+        ApproxMatcher(std::vector<T> const &comparator) : m_comparator(comparator) {}
+
+        bool match(std::vector<T> const &v) const override
+        {
+          if (m_comparator.size() != v.size())
+            return false;
+          for (std::size_t i = 0; i < v.size(); ++i)
+            if (m_comparator[i] != approx(v[i]))
+              return false;
+          return true;
+        }
+        std::string describe() const override
+        {
+          return "is approx: " + ::Catch::Detail::stringify(m_comparator);
+        }
+        template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        ApproxMatcher &epsilon(T const &newEpsilon)
+        {
+          approx.epsilon(newEpsilon);
+          return *this;
+        }
+        template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        ApproxMatcher &margin(T const &newMargin)
+        {
+          approx.margin(newMargin);
+          return *this;
+        }
+        template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        ApproxMatcher &scale(T const &newScale)
+        {
+          approx.scale(newScale);
+          return *this;
+        }
+
+        std::vector<T> const &        m_comparator;
+        mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+      };
+
+      template <typename T> struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>>
+      {
+        UnorderedEqualsMatcher(std::vector<T> const &target) : m_target(target) {}
+        bool match(std::vector<T> const &vec) const override
+        {
+          // Note: This is a reimplementation of std::is_permutation,
+          //       because I don't want to include <algorithm> inside the common path
+          if (m_target.size() != vec.size()) {
+            return false;
+          }
+          return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+        }
+
+        std::string describe() const override
+        {
+          return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+        }
+
+      private:
+        std::vector<T> const &m_target;
+      };
 
     } // namespace Vector
 
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
 
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
+    template <typename T> Vector::ContainsMatcher<T> Contains(std::vector<T> const &comparator)
+    {
+      return Vector::ContainsMatcher<T>(comparator);
     }
 
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
+    template <typename T> Vector::ContainsElementMatcher<T> VectorContains(T const &comparator)
+    {
+      return Vector::ContainsElementMatcher<T>(comparator);
     }
 
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
+    template <typename T> Vector::EqualsMatcher<T> Equals(std::vector<T> const &comparator)
+    {
+      return Vector::EqualsMatcher<T>(comparator);
     }
 
-    template<typename T>
-    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
-        return Vector::ApproxMatcher<T>( comparator );
+    template <typename T> Vector::ApproxMatcher<T> Approx(std::vector<T> const &comparator)
+    {
+      return Vector::ApproxMatcher<T>(comparator);
     }
 
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
+    template <typename T>
+    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const &target)
+    {
+      return Vector::UnorderedEqualsMatcher<T>(target);
     }
 
-} // namespace Matchers
+  } // namespace Matchers
 } // namespace Catch
 
 // end catch_matchers_vector.h
 namespace Catch {
 
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
+  template <typename ArgT, typename MatcherT> class MatchExpr : public ITransientExpression
+  {
+    ArgT const &m_arg;
+    MatcherT    m_matcher;
+    StringRef   m_matcherString;
 
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+  public:
+    MatchExpr(ArgT const &arg, MatcherT const &matcher, StringRef const &matcherString)
+        : ITransientExpression{true, matcher.match(arg)}, m_arg(arg), m_matcher(matcher),
+          m_matcherString(matcherString)
+    {
+    }
 
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+    void streamReconstructedExpression(std::ostream &os) const override
+    {
+      auto matcherAsString = m_matcher.toString();
+      os << Catch::Detail::stringify(m_arg) << ' ';
+      if (matcherAsString == Detail::unprintableString)
+        os << m_matcherString;
+      else
+        os << matcherAsString;
     }
+  };
+
+  using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+  void handleExceptionMatchExpr(AssertionHandler &handler, StringMatcher const &matcher,
+                                StringRef const &matcherString);
+
+  template <typename ArgT, typename MatcherT>
+  auto makeMatchExpr(ArgT const &arg, MatcherT const &matcher, StringRef const &matcherString)
+      -> MatchExpr<ArgT, MatcherT>
+  {
+    return MatchExpr<ArgT, MatcherT>(arg, matcher, matcherString);
+  }
 
 } // namespace Catch
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CHECK_THAT(macroName, matcher, resultDisposition, arg)                            \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(                                                 \
+        macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,                                             \
+        CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition);  \
+    INTERNAL_CATCH_TRY                                                                             \
+    {                                                                                              \
+      catchAssertionHandler.handleExpr(Catch::makeMatchExpr(arg, matcher, #matcher##_catch_sr));   \
+    }                                                                                              \
+    INTERNAL_CATCH_CATCH(catchAssertionHandler)                                                    \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
+#define INTERNAL_CATCH_THROWS_MATCHES(macroName, exceptionType, resultDisposition, matcher, ...)   \
+  do {                                                                                             \
+    Catch::AssertionHandler catchAssertionHandler(                                                 \
+        macroName##_catch_sr, CATCH_INTERNAL_LINEINFO,                                             \
+        CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(                       \
+            exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher),                                 \
+        resultDisposition);                                                                        \
+    if (catchAssertionHandler.allowThrows())                                                       \
+      try {                                                                                        \
+        static_cast<void>(__VA_ARGS__);                                                            \
+        catchAssertionHandler.handleUnexpectedExceptionNotThrown();                                \
+      }                                                                                            \
+      catch (exceptionType const &ex) {                                                            \
+        catchAssertionHandler.handleExpr(Catch::makeMatchExpr(ex, matcher, #matcher##_catch_sr));  \
+      }                                                                                            \
+      catch (...) {                                                                                \
+        catchAssertionHandler.handleUnexpectedInflightException();                                 \
+      }                                                                                            \
+    else                                                                                           \
+      catchAssertionHandler.handleThrowingCallSkipped();                                           \
+    INTERNAL_CATCH_REACT(catchAssertionHandler)                                                    \
+  } while (false)
 
 // end catch_capture_matchers.h
 #endif
@@ -3738,32 +4386,33 @@ namespace Catch {
 
 // start catch_interfaces_generatortracker.h
 
-
 #include <memory>
 
 namespace Catch {
 
-    namespace Generators {
-        class GeneratorUntypedBase {
-        public:
-            GeneratorUntypedBase() = default;
-            virtual ~GeneratorUntypedBase();
-            // Attempts to move the generator to the next element
-             //
-             // Returns true iff the move succeeded (and a valid element
-             // can be retrieved).
-            virtual bool next() = 0;
-        };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
+  namespace Generators {
+    class GeneratorUntypedBase
+    {
+    public:
+      GeneratorUntypedBase() = default;
+      virtual ~GeneratorUntypedBase();
+      // Attempts to move the generator to the next element
+      //
+      // Returns true iff the move succeeded (and a valid element
+      // can be retrieved).
+      virtual bool next() = 0;
+    };
+    using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
 
-    } // namespace Generators
+  } // namespace Generators
 
-    struct IGeneratorTracker {
-        virtual ~IGeneratorTracker();
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
+  struct IGeneratorTracker
+  {
+    virtual ~IGeneratorTracker();
+    virtual auto hasGenerator() const -> bool                                 = 0;
+    virtual auto getGenerator() const -> Generators::GeneratorBasePtr const & = 0;
+    virtual void setGenerator(Generators::GeneratorBasePtr &&generator)       = 0;
+  };
 
 } // namespace Catch
 
@@ -3774,401 +4423,410 @@ namespace Catch {
 
 namespace Catch {
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
+  template <typename Ex>[[noreturn]] void throw_exception(Ex const &e) { throw e; }
 #else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
+  [[noreturn]] void throw_exception(std::exception const &e);
 #endif
 
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
+  [[noreturn]] void throw_logic_error(std::string const &msg);
+  [[noreturn]] void throw_domain_error(std::string const &msg);
+  [[noreturn]] void throw_runtime_error(std::string const &msg);
 
-} // namespace Catch;
+} // namespace Catch
 
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+#define CATCH_MAKE_MSG(...) (Catch::ReusableStringStream() << __VA_ARGS__).str()
 
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__));
+#define CATCH_INTERNAL_ERROR(...)                                                                  \
+  Catch::throw_logic_error(                                                                        \
+      CATCH_MAKE_MSG(CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
 
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
+#define CATCH_ERROR(...) Catch::throw_domain_error(CATCH_MAKE_MSG(__VA_ARGS__))
 
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
+#define CATCH_RUNTIME_ERROR(...) Catch::throw_runtime_error(CATCH_MAKE_MSG(__VA_ARGS__))
 
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+#define CATCH_ENFORCE(condition, ...)                                                              \
+  do {                                                                                             \
+    if (!(condition))                                                                              \
+      CATCH_ERROR(__VA_ARGS__);                                                                    \
+  } while (false)
 
 // end catch_enforce.h
+#include <cassert>
 #include <memory>
 #include <vector>
-#include <cassert>
 
-#include <utility>
 #include <exception>
+#include <utility>
 
 namespace Catch {
 
-class GeneratorException : public std::exception {
-    const char* const m_msg = "";
+  class GeneratorException : public std::exception
+  {
+    const char *const m_msg = "";
 
-public:
-    GeneratorException(const char* msg):
-        m_msg(msg)
-    {}
+  public:
+    GeneratorException(const char *msg) : m_msg(msg) {}
 
-    const char* what() const noexcept override final;
-};
+    const char *what() const noexcept override final;
+  };
 
-namespace Generators {
+  namespace Generators {
 
     // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
-    template<typename T>
-    struct IGenerator : GeneratorUntypedBase {
-        virtual ~IGenerator() = default;
-
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
+    namespace pf {
+      template <typename T, typename... Args> std::unique_ptr<T> make_unique(Args &&... args)
+      {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+      }
+    } // namespace pf
+
+    template <typename T> struct IGenerator : GeneratorUntypedBase
+    {
+      virtual ~IGenerator() = default;
+
+      // Returns the current element of the generator
+      //
+      // \Precondition The generator is either freshly constructed,
+      // or the last call to `next()` returned true
+      virtual T const &get() const = 0;
+      using type                   = T;
     };
 
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
+    template <typename T> class SingleValueGenerator final : public IGenerator<T>
+    {
+      T m_value;
+
     public:
-        SingleValueGenerator(T const& value) : m_value( value ) {}
-        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
+      SingleValueGenerator(T const &value) : m_value(value) {}
+      SingleValueGenerator(T &&value) : m_value(std::move(value)) {}
 
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
+      T const &get() const override { return m_value; }
+      bool     next() override { return false; }
     };
 
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "ValuesGenerator does not support bools because of std::vector<bool>"
-            "specialization, use SingleValue Generator instead.");
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+    template <typename T> class FixedValuesGenerator final : public IGenerator<T>
+    {
+      static_assert(!std::is_same<T, bool>::value,
+                    "FixedValuesGenerator does not support bools because of std::vector<bool>"
+                    "specialization, use SingleValue Generator instead.");
+      std::vector<T> m_values;
+      size_t         m_idx = 0;
 
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
+    public:
+      FixedValuesGenerator(std::initializer_list<T> values) : m_values(values) {}
+
+      T const &get() const override { return m_values[m_idx]; }
+      bool     next() override
+      {
+        ++m_idx;
+        return m_idx < m_values.size();
+      }
     };
 
-    template <typename T>
-    class GeneratorWrapper final {
-        std::unique_ptr<IGenerator<T>> m_generator;
+    template <typename T> class GeneratorWrapper final
+    {
+      std::unique_ptr<IGenerator<T>> m_generator;
+
     public:
-        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
-            m_generator(std::move(generator))
-        {}
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->next();
-        }
+      GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator) : m_generator(std::move(generator))
+      {
+      }
+      T const &get() const { return m_generator->get(); }
+      bool     next() { return m_generator->next(); }
     };
 
-    template <typename T>
-    GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    template <typename T> GeneratorWrapper<T> value(T &&value)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
     }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    template <typename T> GeneratorWrapper<T> values(std::initializer_list<T> values)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
     }
 
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void populate(GeneratorWrapper<T>&& generator) {
-            m_generators.emplace_back(std::move(generator));
-        }
-        void populate(T&& val) {
-            m_generators.emplace_back(value(std::move(val)));
-        }
-        template<typename U>
-        void populate(U&& val) {
-            populate(T(std::move(val)));
-        }
-        template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs... moreGenerators) {
-            populate(std::forward<U>(valueOrGenerator));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
+    template <typename T> class Generators : public IGenerator<T>
+    {
+      std::vector<GeneratorWrapper<T>> m_generators;
+      size_t                           m_current = 0;
+
+      void populate(GeneratorWrapper<T> &&generator)
+      {
+        m_generators.emplace_back(std::move(generator));
+      }
+      void populate(T &&val) { m_generators.emplace_back(value(std::move(val))); }
+      template <typename U> void populate(U &&val) { populate(T(std::move(val))); }
+      template <typename U, typename... Gs>
+      void populate(U &&valueOrGenerator, Gs... moreGenerators)
+      {
+        populate(std::forward<U>(valueOrGenerator));
+        populate(std::forward<Gs>(moreGenerators)...);
+      }
 
     public:
-        template <typename... Gs>
-        Generators(Gs... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
+      template <typename... Gs> Generators(Gs... moreGenerators)
+      {
+        m_generators.reserve(sizeof...(Gs));
+        populate(std::forward<Gs>(moreGenerators)...);
+      }
 
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
+      T const &get() const override { return m_generators[m_current].get(); }
 
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
+      bool next() override
+      {
+        if (m_current >= m_generators.size()) {
+          return false;
+        }
+        const bool current_status = m_generators[m_current].next();
+        if (!current_status) {
+          ++m_current;
         }
+        return m_current < m_generators.size();
+      }
     };
 
-    template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
+    template <typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>>
+    table(std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples)
+    {
+      return values<std::tuple<Ts...>>(tuples);
     }
 
     // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
+    template <typename T> struct as
+    {
+    };
 
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs... moreGenerators ) -> Generators<T> {
-        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    template <typename T, typename... Gs>
+    auto makeGenerators(GeneratorWrapper<T> &&generator, Gs... moreGenerators) -> Generators<T>
+    {
+      return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
     }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(std::move(generator));
+    template <typename T> auto makeGenerators(GeneratorWrapper<T> &&generator) -> Generators<T>
+    {
+      return Generators<T>(std::move(generator));
     }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    template <typename T, typename... Gs>
+    auto makeGenerators(T &&val, Gs... moreGenerators) -> Generators<T>
+    {
+      return makeGenerators(value(std::forward<T>(val)), std::forward<Gs>(moreGenerators)...);
     }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    template <typename T, typename U, typename... Gs>
+    auto makeGenerators(as<T>, U &&val, Gs... moreGenerators) -> Generators<T>
+    {
+      return makeGenerators(value(T(std::forward<U>(val))), std::forward<Gs>(moreGenerators)...);
     }
 
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+    auto acquireGeneratorTracker(SourceLineInfo const &lineInfo) -> IGeneratorTracker &;
 
-    template<typename L>
+    template <typename L>
     // Note: The type after -> is weird, because VS2015 cannot parse
     //       the expression used in the typedef inside, when it is in
     //       return type. Yeah.
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
+    auto generate(SourceLineInfo const &lineInfo, L const &generatorExpression)
+        -> decltype(std::declval<decltype(generatorExpression())>().get())
+    {
+      using UnderlyingType = typename decltype(generatorExpression())::type;
 
-        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
-        }
+      IGeneratorTracker &tracker = acquireGeneratorTracker(lineInfo);
+      if (!tracker.hasGenerator()) {
+        tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+      }
 
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator.get();
+      auto const &generator =
+          static_cast<IGenerator<UnderlyingType> const &>(*tracker.getGenerator());
+      return generator.get();
     }
 
-} // namespace Generators
+  } // namespace Generators
 } // namespace Catch
 
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
-
-// end catch_generators.hpp
-// start catch_generators_generic.hpp
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
+#define GENERATE(...)                                                                              \
+  Catch::Generators::generate(CATCH_INTERNAL_LINEINFO, [] {                                        \
+    using namespace Catch::Generators;                                                             \
+    return makeGenerators(__VA_ARGS__);                                                            \
+  })
+#define GENERATE_COPY(...)                                                                         \
+  Catch::Generators::generate(CATCH_INTERNAL_LINEINFO, [=] {                                       \
+    using namespace Catch::Generators;                                                             \
+    return makeGenerators(__VA_ARGS__);                                                            \
+  })
+#define GENERATE_REF(...)                                                                          \
+  Catch::Generators::generate(CATCH_INTERNAL_LINEINFO, [&] {                                       \
+    using namespace Catch::Generators;                                                             \
+    return makeGenerators(__VA_ARGS__);                                                            \
+  })
 
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
-    }
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
 
-    template <typename T, typename Predicate>
-    class FilterGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_predicate(std::forward<P>(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
-                }
-            }
-        }
+namespace Catch {
+  namespace Generators {
 
-        T const& get() const override {
-            return m_generator.get();
-        }
+    template <typename T> class TakeGenerator : public IGenerator<T>
+    {
+      GeneratorWrapper<T> m_generator;
+      size_t              m_returned = 0;
+      size_t              m_target;
 
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
+    public:
+      TakeGenerator(size_t target, GeneratorWrapper<T> &&generator)
+          : m_generator(std::move(generator)), m_target(target)
+      {
+        assert(target != 0 && "Empty generators are not allowed");
+      }
+      T const &get() const override { return m_generator.get(); }
+      bool     next() override
+      {
+        ++m_returned;
+        if (m_returned >= m_target) {
+          return false;
+        }
+
+        const auto success = m_generator.next();
+        // If the underlying generator does not contain enough values
+        // then we cut short as well
+        if (!success) {
+          m_returned = m_target;
+        }
+        return success;
+      }
     };
 
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    template <typename T> GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T> &&generator)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
     }
 
-    template <typename T>
-    class RepeatGenerator : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "RepeatGenerator currently does not support bools"
-            "because of std::vector<bool> specialization");
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
+    template <typename T, typename Predicate> class FilterGenerator : public IGenerator<T>
+    {
+      GeneratorWrapper<T> m_generator;
+      Predicate           m_predicate;
+
     public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
+      template <typename P = Predicate>
+      FilterGenerator(P &&pred, GeneratorWrapper<T> &&generator)
+          : m_generator(std::move(generator)), m_predicate(std::forward<P>(pred))
+      {
+        if (!m_predicate(m_generator.get())) {
+          // It might happen that there are no values that pass the
+          // filter. In that case we throw an exception.
+          auto has_initial_value = next();
+          if (!has_initial_value) {
+            Catch::throw_exception(
+                GeneratorException("No valid value found in filtered generator"));
+          }
+        }
+      }
+
+      T const &get() const override { return m_generator.get(); }
+
+      bool next() override
+      {
+        bool success = m_generator.next();
+        if (!success) {
+          return false;
+        }
+        while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true)
+          ;
+        return success;
+      }
+    };
 
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate &&pred, GeneratorWrapper<T> &&generator)
+    {
+      return GeneratorWrapper<T>(
+          std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(
+              std::forward<Predicate>(pred), std::move(generator))));
+    }
 
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
+    template <typename T> class RepeatGenerator : public IGenerator<T>
+    {
+      static_assert(!std::is_same<T, bool>::value,
+                    "RepeatGenerator currently does not support bools"
+                    "because of std::vector<bool> specialization");
+      GeneratorWrapper<T>    m_generator;
+      mutable std::vector<T> m_returned;
+      size_t                 m_target_repeats;
+      size_t                 m_current_repeat = 0;
+      size_t                 m_repeat_index   = 0;
 
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
+    public:
+      RepeatGenerator(size_t repeats, GeneratorWrapper<T> &&generator)
+          : m_generator(std::move(generator)), m_target_repeats(repeats)
+      {
+        assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+      }
+
+      T const &get() const override
+      {
+        if (m_current_repeat == 0) {
+          m_returned.push_back(m_generator.get());
+          return m_returned.back();
+        }
+        return m_returned[m_repeat_index];
+      }
+
+      bool next() override
+      {
+        // There are 2 basic cases:
+        // 1) We are still reading the generator
+        // 2) We are reading our own cache
+
+        // In the first case, we need to poke the underlying generator.
+        // If it happily moves, we are left in that state, otherwise it is time to start reading
+        // from our cache
+        if (m_current_repeat == 0) {
+          const auto success = m_generator.next();
+          if (!success) {
+            ++m_current_repeat;
+          }
+          return m_current_repeat < m_target_repeats;
+        }
+
+        // In the second case, we need to move indices forward and check that we haven't run up
+        // against the end
+        ++m_repeat_index;
+        if (m_repeat_index == m_returned.size()) {
+          m_repeat_index = 0;
+          ++m_current_repeat;
+        }
+        return m_current_repeat < m_target_repeats;
+      }
     };
 
     template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T> &&generator)
+    {
+      return GeneratorWrapper<T>(
+          pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
     }
 
-    template <typename T, typename U, typename Func>
-    class MapGenerator : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
+    template <typename T, typename U, typename Func> class MapGenerator : public IGenerator<T>
+    {
+      // TBD: provide static assert for mapping function, for friendly error message
+      GeneratorWrapper<U> m_generator;
+      Func                m_function;
+      // To avoid returning dangling reference, we have to save the values
+      T m_cache;
+
     public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(std::move(generator)),
-            m_function(std::forward<F2>(function)),
+      template <typename F2 = Func>
+      MapGenerator(F2 &&function, GeneratorWrapper<U> &&generator)
+          : m_generator(std::move(generator)), m_function(std::forward<F2>(function)),
             m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
+      {
+      }
+
+      T const &get() const override { return m_cache; }
+      bool     next() override
+      {
+        const auto success = m_generator.next();
+        if (success) {
+          m_cache = m_function(m_generator.get());
+        }
+        return success;
+      }
     };
 
 #if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
@@ -4176,70 +4834,73 @@ namespace Generators {
     // replaced with std::invoke_result here. Also *_t format is preferred over
     // typename *::type format.
     template <typename Func, typename U>
-    using MapFunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+    using MapFunctionReturnType =
+        std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
 #else
     template <typename Func, typename U>
-    using MapFunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+    using MapFunctionReturnType = typename std::remove_reference<
+        typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
 #endif
 
     template <typename Func, typename U, typename T = MapFunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
+    GeneratorWrapper<T> map(Func &&function, GeneratorWrapper<U> &&generator)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<MapGenerator<T, U, Func>>(
+          std::forward<Func>(function), std::move(generator)));
     }
 
     template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
+    GeneratorWrapper<T> map(Func &&function, GeneratorWrapper<U> &&generator)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<MapGenerator<T, U, Func>>(
+          std::forward<Func>(function), std::move(generator)));
     }
 
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
+    template <typename T> class ChunkGenerator final : public IGenerator<std::vector<T>>
+    {
+      std::vector<T>      m_chunk;
+      size_t              m_chunk_size;
+      GeneratorWrapper<T> m_generator;
+      bool                m_used_up = false;
+
     public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(std::move(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            if (m_chunk_size != 0) {
-                m_chunk.push_back(m_generator.get());
-                for (size_t i = 1; i < m_chunk_size; ++i) {
-                    if (!m_generator.next()) {
-                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
-                    }
-                    m_chunk.push_back(m_generator.get());
-                }
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
+      ChunkGenerator(size_t size, GeneratorWrapper<T> generator)
+          : m_chunk_size(size), m_generator(std::move(generator))
+      {
+        m_chunk.reserve(m_chunk_size);
+        if (m_chunk_size != 0) {
+          m_chunk.push_back(m_generator.get());
+          for (size_t i = 1; i < m_chunk_size; ++i) {
+            if (!m_generator.next()) {
+              Catch::throw_exception(
+                  GeneratorException("Not enough values to initialize the first chunk"));
             }
-            return true;
+            m_chunk.push_back(m_generator.get());
+          }
+        }
+      }
+      std::vector<T> const &get() const override { return m_chunk; }
+      bool                  next() override
+      {
+        m_chunk.clear();
+        for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+          if (!m_generator.next()) {
+            return false;
+          }
+          m_chunk.push_back(m_generator.get());
         }
+        return true;
+      }
     };
 
     template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
-        );
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T> &&generator)
+    {
+      return GeneratorWrapper<std::vector<T>>(
+          pf::make_unique<ChunkGenerator<T>>(size, std::move(generator)));
     }
 
-} // namespace Generators
+  } // namespace Generators
 } // namespace Catch
 
 // end catch_generators_generic.hpp
@@ -4251,50 +4912,51 @@ namespace Generators {
 
 namespace Catch {
 
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
+  struct IResultCapture;
+  struct IRunner;
+  struct IConfig;
+  struct IMutableContext;
+
+  using IConfigPtr = std::shared_ptr<IConfig const>;
+
+  struct IContext
+  {
+    virtual ~IContext();
+
+    virtual IResultCapture *  getResultCapture() = 0;
+    virtual IRunner *         getRunner()        = 0;
+    virtual IConfigPtr const &getConfig() const  = 0;
+  };
+
+  struct IMutableContext : IContext
+  {
+    virtual ~IMutableContext();
+    virtual void setResultCapture(IResultCapture *resultCapture) = 0;
+    virtual void setRunner(IRunner *runner)                      = 0;
+    virtual void setConfig(IConfigPtr const &config)             = 0;
+
+  private:
+    static IMutableContext *currentContext;
+    friend IMutableContext &getCurrentMutableContext();
+    friend void             cleanUpContext();
+    static void             createContext();
+  };
+
+  inline IMutableContext &getCurrentMutableContext()
+  {
+    if (!IMutableContext::currentContext)
+      IMutableContext::createContext();
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return *IMutableContext::currentContext;
+  }
 
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        return *IMutableContext::currentContext;
-    }
+  inline IContext &getCurrentContext() { return getCurrentMutableContext(); }
 
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
+  void cleanUpContext();
 
-    void cleanUpContext();
-}
+  class SimplePcg32;
+  SimplePcg32 &rng();
+} // namespace Catch
 
 // end catch_context.h
 // start catch_interfaces_config.h
@@ -4303,259 +4965,329 @@ namespace Catch {
 
 namespace Catch {
 
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
+  // An optional type
+  template <typename T> class Option
+  {
+  public:
+    Option() : nullableValue(nullptr) {}
+    Option(T const &_value) : nullableValue(new (storage) T(_value)) {}
+    Option(Option const &_other) : nullableValue(_other ? new (storage) T(*_other) : nullptr) {}
 
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
+    ~Option() { reset(); }
 
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
+    Option &operator=(Option const &_other)
+    {
+      if (&_other != this) {
+        reset();
+        if (_other)
+          nullableValue = new (storage) T(*_other);
+      }
+      return *this;
+    }
+    Option &operator=(T const &_value)
+    {
+      reset();
+      nullableValue = new (storage) T(_value);
+      return *this;
+    }
+
+    void reset()
+    {
+      if (nullableValue)
+        nullableValue->~T();
+      nullableValue = nullptr;
+    }
 
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
+    T &      operator*() { return *nullableValue; }
+    T const &operator*() const { return *nullableValue; }
+    T *      operator->() { return nullableValue; }
+    const T *operator->() const { return nullableValue; }
 
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
+    T valueOr(T const &defaultValue) const { return nullableValue ? *nullableValue : defaultValue; }
 
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
+    bool some() const { return nullableValue != nullptr; }
+    bool none() const { return nullableValue == nullptr; }
 
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
+    bool     operator!() const { return nullableValue == nullptr; }
+    explicit operator bool() const { return some(); }
 
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
+  private:
+    T *nullableValue;
+    alignas(alignof(T)) char storage[sizeof(T)];
+  };
 
 } // end namespace Catch
 
 // end catch_option.hpp
 #include <iosfwd>
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
 
 namespace Catch {
 
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
+  enum class Verbosity { Quiet = 0, Normal, High };
+
+  struct WarnAbout
+  {
+    enum What { Nothing = 0x00, NoAssertions = 0x01, NoTests = 0x02 };
+  };
+
+  struct ShowDurations
+  {
+    enum OrNot { DefaultForReporter, Always, Never };
+  };
+  struct RunTests
+  {
+    enum InWhatOrder { InDeclarationOrder, InLexicographicalOrder, InRandomOrder };
+  };
+  struct UseColour
+  {
+    enum YesOrNo { Auto, Yes, No };
+  };
+  struct WaitForKeypress
+  {
+    enum When {
+      Never,
+      BeforeStart        = 1,
+      BeforeExit         = 2,
+      BeforeStartAndExit = BeforeStart | BeforeExit
     };
+  };
+
+  class TestSpec;
+
+  struct IConfig : NonCopyable
+  {
+
+    virtual ~IConfig();
+
+    virtual bool                            allowThrows() const                = 0;
+    virtual std::ostream &                  stream() const                     = 0;
+    virtual std::string                     name() const                       = 0;
+    virtual bool                            includeSuccessfulResults() const   = 0;
+    virtual bool                            shouldDebugBreak() const           = 0;
+    virtual bool                            warnAboutMissingAssertions() const = 0;
+    virtual bool                            warnAboutNoTests() const           = 0;
+    virtual int                             abortAfter() const                 = 0;
+    virtual bool                            showInvisibles() const             = 0;
+    virtual ShowDurations::OrNot            showDurations() const              = 0;
+    virtual TestSpec const &                testSpec() const                   = 0;
+    virtual bool                            hasTestFilters() const             = 0;
+    virtual std::vector<std::string> const &getTestsOrTags() const             = 0;
+    virtual RunTests::InWhatOrder           runOrder() const                   = 0;
+    virtual unsigned int                    rngSeed() const                    = 0;
+    virtual UseColour::YesOrNo              useColour() const                  = 0;
+    virtual std::vector<std::string> const &getSectionsToRun() const           = 0;
+    virtual Verbosity                       verbosity() const                  = 0;
+
+    virtual bool         benchmarkNoAnalysis() const         = 0;
+    virtual int          benchmarkSamples() const            = 0;
+    virtual double       benchmarkConfidenceInterval() const = 0;
+    virtual unsigned int benchmarkResamples() const          = 0;
+  };
+
+  using IConfigPtr = std::shared_ptr<IConfig const>;
+} // namespace Catch
 
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-    };
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
 
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
+#include <cstdint>
 
-// end catch_interfaces_config.h
+namespace Catch {
+
+  // This is a simple implementation of C++11 Uniform Random Number
+  // Generator. It does not provide all operators, because Catch2
+  // does not use it, but it should behave as expected inside stdlib's
+  // distributions.
+  // The implementation is based on the PCG family (http://pcg-random.org)
+  class SimplePcg32
+  {
+    using state_type = std::uint64_t;
+
+  public:
+    using result_type = std::uint32_t;
+    static constexpr result_type(min)() { return 0; }
+    static constexpr result_type(max)() { return static_cast<result_type>(-1); }
+
+    // Provide some default initial state for the default constructor
+    SimplePcg32() : SimplePcg32(0xed743cc4U) {}
+
+    explicit SimplePcg32(result_type seed_);
+
+    void seed(result_type seed_);
+    void discard(uint64_t skip);
+
+    result_type operator()();
+
+  private:
+    friend bool operator==(SimplePcg32 const &lhs, SimplePcg32 const &rhs);
+    friend bool operator!=(SimplePcg32 const &lhs, SimplePcg32 const &rhs);
+
+    // In theory we also need operator<< and operator>>
+    // In practice we do not use them, so we will skip them for now
+
+    std::uint64_t m_state;
+    // This part of the state determines which "stream" of the numbers
+    // is chosen -- we take it as a constant for Catch2, so we only
+    // need to deal with seeding the main state.
+    // Picked by reading 8 bytes from `/dev/random` :-)
+    static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+  };
+
+} // end namespace Catch
+
+// end catch_random_number_generator.h
 #include <random>
 
 namespace Catch {
-namespace Generators {
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    // FIXME: What is the right seed?
-    std::minstd_rand m_rand;
-    std::uniform_real_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-
-    RandomFloatingGenerator(Float a, Float b):
-        m_rand(getCurrentContext().getConfig()->rngSeed()),
-        m_dist(a, b) {
+  namespace Generators {
+
+    template <typename Float> class RandomFloatingGenerator final : public IGenerator<Float>
+    {
+      Catch::SimplePcg32 &                  m_rng;
+      std::uniform_real_distribution<Float> m_dist;
+      Float                                 m_current_number;
+
+    public:
+      RandomFloatingGenerator(Float a, Float b) : m_rng(rng()), m_dist(a, b)
+      {
         static_cast<void>(next());
-    }
+      }
 
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rand);
+      Float const &get() const override { return m_current_number; }
+      bool         next() override
+      {
+        m_current_number = m_dist(m_rng);
         return true;
-    }
-};
+      }
+    };
 
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    std::minstd_rand m_rand;
-    std::uniform_int_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
+    template <typename Integer> class RandomIntegerGenerator final : public IGenerator<Integer>
+    {
+      Catch::SimplePcg32 &                   m_rng;
+      std::uniform_int_distribution<Integer> m_dist;
+      Integer                                m_current_number;
 
-    RandomIntegerGenerator(Integer a, Integer b):
-        m_rand(getCurrentContext().getConfig()->rngSeed()),
-        m_dist(a, b) {
+    public:
+      RandomIntegerGenerator(Integer a, Integer b) : m_rng(rng()), m_dist(a, b)
+      {
         static_cast<void>(next());
-    }
+      }
 
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rand);
+      Integer const &get() const override { return m_current_number; }
+      bool           next() override
+      {
+        m_current_number = m_dist(m_rng);
         return true;
-    }
-};
-
-// TODO: Ideally this would be also constrained against the various char types,
-//       but I don't expect users to run into that in practice.
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
-    );
-}
+      }
+    };
 
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
-    );
-}
+    // TODO: Ideally this would be also constrained against the various char types,
+    //       but I don't expect users to run into that in practice.
+    template <typename T>
+    typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+                            GeneratorWrapper<T>>::type
+    random(T a, T b)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<RandomIntegerGenerator<T>>(a, b));
+    }
 
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
+    template <typename T>
+    typename std::enable_if<std::is_floating_point<T>::value, GeneratorWrapper<T>>::type random(T a,
+                                                                                                T b)
+    {
+      return GeneratorWrapper<T>(pf::make_unique<RandomFloatingGenerator<T>>(a, b));
+    }
 
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
+    template <typename T> class RangeGenerator final : public IGenerator<T>
     {
+      T    m_current;
+      T    m_end;
+      T    m_step;
+      bool m_positive;
+
+    public:
+      RangeGenerator(T const &start, T const &end, T const &step)
+          : m_current(start), m_end(end), m_step(step), m_positive(m_step > T(0))
+      {
         assert(m_current != m_end && "Range start and end cannot be equal");
         assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) &&
+               "Step moves away from end");
+      }
 
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
+      RangeGenerator(T const &start, T const &end)
+          : RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+      {
+      }
 
-    T const& get() const override {
-        return m_current;
-    }
+      T const &get() const override { return m_current; }
 
-    bool next() override {
+      bool next() override
+      {
         m_current += m_step;
         return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+      }
+    };
+
+    template <typename T> GeneratorWrapper<T> range(T const &start, T const &end, T const &step)
+    {
+      static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value,
+                    "Type must be an integer");
+      return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
     }
-};
 
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
-}
+    template <typename T> GeneratorWrapper<T> range(T const &start, T const &end)
+    {
+      static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value,
+                    "Type must be an integer");
+      return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+    }
 
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
-}
+    template <typename T> class IteratorGenerator final : public IGenerator<T>
+    {
+      static_assert(!std::is_same<T, bool>::value,
+                    "IteratorGenerator currently does not support bools"
+                    "because of std::vector<bool> specialization");
+
+      std::vector<T> m_elems;
+      size_t         m_current = 0;
+
+    public:
+      template <typename InputIterator, typename InputSentinel>
+      IteratorGenerator(InputIterator first, InputSentinel last) : m_elems(first, last)
+      {
+        if (m_elems.empty()) {
+          Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+      }
+
+      T const &get() const override { return m_elems[m_current]; }
 
-} // namespace Generators
+      bool next() override
+      {
+        ++m_current;
+        return m_current != m_elems.size();
+      }
+    };
+
+    template <typename InputIterator, typename InputSentinel,
+              typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+    GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to)
+    {
+      return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+    }
+
+    template <typename Container, typename ResultType = typename Container::value_type>
+    GeneratorWrapper<ResultType> from_range(Container const &cnt)
+    {
+      return GeneratorWrapper<ResultType>(
+          pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+    }
+
+  } // namespace Generators
 } // namespace Catch
 
 // end catch_generators_specific.hpp
@@ -4564,9 +5296,9 @@ GeneratorWrapper<T> range(T const& start, T const& end) {
 // in the conditionally compiled sections
 // start catch_test_case_info.h
 
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ -4575,66 +5307,63 @@ GeneratorWrapper<T> range(T const& start, T const& end) {
 
 namespace Catch {
 
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
+  struct ITestInvoker;
+
+  struct TestCaseInfo
+  {
+    enum SpecialProperties {
+      None        = 0,
+      IsHidden    = 1 << 1,
+      ShouldFail  = 1 << 2,
+      MayFail     = 1 << 3,
+      Throws      = 1 << 4,
+      NonPortable = 1 << 5,
+      Benchmark   = 1 << 6
+    };
 
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+    TestCaseInfo(std::string const &_name, std::string const &_className,
+                 std::string const &_description, std::vector<std::string> const &_tags,
+                 SourceLineInfo const &_lineInfo);
 
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
+    friend void setTags(TestCaseInfo &testCaseInfo, std::vector<std::string> tags);
 
-        std::string tagsAsString() const;
+    bool isHidden() const;
+    bool throws() const;
+    bool okToFail() const;
+    bool expectedToFail() const;
 
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
+    std::string tagsAsString() const;
 
-    class TestCase : public TestCaseInfo {
-    public:
+    std::string              name;
+    std::string              className;
+    std::string              description;
+    std::vector<std::string> tags;
+    std::vector<std::string> lcaseTags;
+    SourceLineInfo           lineInfo;
+    SpecialProperties        properties;
+  };
 
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+  class TestCase : public TestCaseInfo
+  {
+  public:
+    TestCase(ITestInvoker *testCase, TestCaseInfo &&info);
 
-        TestCase withName( std::string const& _newName ) const;
+    TestCase withName(std::string const &_newName) const;
 
-        void invoke() const;
+    void invoke() const;
 
-        TestCaseInfo const& getTestCaseInfo() const;
+    TestCaseInfo const &getTestCaseInfo() const;
 
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
+    bool operator==(TestCase const &other) const;
+    bool operator<(TestCase const &other) const;
 
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
+  private:
+    std::shared_ptr<ITestInvoker> test;
+  };
 
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
+  TestCase makeTestCase(ITestInvoker *testCase, std::string const &className,
+                        NameAndTags const &nameAndTags, SourceLineInfo const &lineInfo);
+} // namespace Catch
 
 #ifdef __clang__
 #pragma clang diagnostic pop
@@ -4645,11 +5374,12 @@ namespace Catch {
 
 namespace Catch {
 
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
+  struct IRunner
+  {
+    virtual ~IRunner();
+    virtual bool aborting() const = 0;
+  };
+} // namespace Catch
 
 // end catch_interfaces_runner.h
 
@@ -4671,188 +5401,204 @@ namespace Catch {
 
 @optional
 
--(void) setUp;
--(void) tearDown;
+- (void)setUp;
+- (void)tearDown;
 
 @end
 
 namespace Catch {
 
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
+  class OcMethod : public ITestInvoker
+  {
 
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
+  public:
+    OcMethod(Class cls, SEL sel) : m_cls(cls), m_sel(sel) {}
 
-        Class m_cls;
-        SEL m_sel;
-    };
+    virtual void invoke() const
+    {
+      id obj = [[m_cls alloc] init];
 
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
+      performOptionalSelector(obj, @selector(setUp));
+      performOptionalSelector(obj, m_sel);
+      performOptionalSelector(obj, @selector(tearDown));
 
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
+      arcSafeRelease(obj);
     }
 
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+  private:
+    virtual ~OcMethod() {}
 
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
+    Class m_cls;
+    SEL   m_sel;
+  };
 
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
+  namespace Detail {
 
-                bool match( NSString* str ) const override {
-                    return false;
-                }
+    inline std::string getAnnotation(Class cls, std::string const &annotationName,
+                                     std::string const &testCaseName)
+    {
+      NSString *selStr = [[NSString alloc]
+          initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+      SEL       sel    = NSSelectorFromString(selStr);
+      arcSafeRelease(selStr);
+      id value = performOptionalSelector(cls, sel);
+      if (value)
+        return [(NSString *)value UTF8String];
+      return "";
+    }
+  } // namespace Detail
+
+  inline std::size_t registerTestMethods()
+  {
+    std::size_t noTestMethods = 0;
+    int         noClasses     = objc_getClassList(nullptr, 0);
+
+    Class *classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc(sizeof(Class) * noClasses);
+    objc_getClassList(classes, noClasses);
+
+    for (int c = 0; c < noClasses; c++) {
+      Class cls = classes[c];
+      {
+        u_int   count;
+        Method *methods = class_copyMethodList(cls, &count);
+        for (u_int m = 0; m < count; m++) {
+          SEL         selector   = method_getName(methods[m]);
+          std::string methodName = sel_getName(selector);
+          if (startsWith(methodName, "Catch_TestCase_")) {
+            std::string testCaseName = methodName.substr(15);
+            std::string name         = Detail::getAnnotation(cls, "Name", testCaseName);
+            std::string desc         = Detail::getAnnotation(cls, "Description", testCaseName);
+            const char *className    = class_getName(cls);
+
+            getMutableRegistryHub().registerTest(
+                makeTestCase(new OcMethod(cls, selector), className,
+                             NameAndTags(name.c_str(), desc.c_str()), SourceLineInfo("", 0)));
+            noTestMethods++;
+          }
+        }
+        free(methods);
+      }
+    }
+    return noTestMethods;
+  }
 
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
 
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
+  namespace Matchers {
+    namespace Impl {
+      namespace NSStringMatchers {
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
+        struct StringHolder : MatcherBase<NSString *>
+        {
+          StringHolder(NSString *substr) : m_substr([substr copy]) {}
+          StringHolder(StringHolder const &other) : m_substr([other.m_substr copy]) {}
+          StringHolder() { arcSafeRelease(m_substr); }
 
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+          bool match(NSString *str) const override { return false; }
 
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
+          NSString *CATCH_ARC_STRONG m_substr;
+        };
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
+        struct Equals : StringHolder
+        {
+          Equals(NSString *substr) : StringHolder(substr) {}
 
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+          bool match(NSString *str) const override
+          {
+            return (str != nil || m_substr == nil) && [str isEqualToString:m_substr];
+          }
 
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
+          std::string describe() const override
+          {
+            return "equals string: " + Catch::Detail::stringify(m_substr);
+          }
+        };
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
+        struct Contains : StringHolder
+        {
+          Contains(NSString *substr) : StringHolder(substr) {}
+
+          bool match(NSString *str) const override
+          {
+            return (str != nil || m_substr == nil) &&
+                   [str rangeOfString:m_substr].location != NSNotFound;
+          }
+
+          std::string describe() const override
+          {
+            return "contains string: " + Catch::Detail::stringify(m_substr);
+          }
+        };
 
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
+        struct StartsWith : StringHolder
+        {
+          StartsWith(NSString *substr) : StringHolder(substr) {}
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
+          bool match(NSString *str) const override
+          {
+            return (str != nil || m_substr == nil) && [str rangeOfString:m_substr].location == 0;
+          }
 
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+          std::string describe() const override
+          {
+            return "starts with: " + Catch::Detail::stringify(m_substr);
+          }
+        };
+        struct EndsWith : StringHolder
+        {
+          EndsWith(NSString *substr) : StringHolder(substr) {}
+
+          bool match(NSString *str) const override
+          {
+            return (str != nil || m_substr == nil) &&
+                   [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+          }
+
+          std::string describe() const override
+          {
+            return "ends with: " + Catch::Detail::stringify(m_substr);
+          }
+        };
 
-        } // namespace NSStringMatchers
-        } // namespace Impl
+      } // namespace NSStringMatchers
+    }   // namespace Impl
 
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+    inline Impl::NSStringMatchers::Equals Equals(NSString *substr)
+    {
+      return Impl::NSStringMatchers::Equals(substr);
+    }
 
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+    inline Impl::NSStringMatchers::Contains Contains(NSString *substr)
+    {
+      return Impl::NSStringMatchers::Contains(substr);
+    }
 
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+    inline Impl::NSStringMatchers::StartsWith StartsWith(NSString *substr)
+    {
+      return Impl::NSStringMatchers::StartsWith(substr);
+    }
 
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+    inline Impl::NSStringMatchers::EndsWith EndsWith(NSString *substr)
+    {
+      return Impl::NSStringMatchers::EndsWith(substr);
+    }
 
-    } // namespace Matchers
+  } // namespace Matchers
 
-    using namespace Matchers;
+  using namespace Matchers;
 
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 } // namespace Catch
 
 ///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
-
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+#define OC_MAKE_UNIQUE_NAME(root, uniqueSuffix) root##uniqueSuffix
+#define OC_TEST_CASE2(name, desc, uniqueSuffix)                                                    \
+  +(NSString *)OC_MAKE_UNIQUE_NAME(Catch_Name_test_, uniqueSuffix) { return @name; }               \
+  +(NSString *)OC_MAKE_UNIQUE_NAME(Catch_Description_test_, uniqueSuffix) { return @desc; }        \
+  -(void)OC_MAKE_UNIQUE_NAME(Catch_TestCase_test_, uniqueSuffix)
+
+#define OC_TEST_CASE(name, desc) OC_TEST_CASE2(name, desc, __LINE__)
 
 // end catch_objc.hpp
 #endif
@@ -4883,99 +5629,111 @@ return @ desc; \
 
 // start catch_wildcard_pattern.h
 
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string adjustCase( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
+namespace Catch {
+  class WildcardPattern
+  {
+    enum WildcardPosition {
+      NoWildcard         = 0,
+      WildcardAtStart    = 1,
+      WildcardAtEnd      = 2,
+      WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
     };
-}
+
+  public:
+    WildcardPattern(std::string const &pattern, CaseSensitive::Choice caseSensitivity);
+    virtual ~WildcardPattern() = default;
+    virtual bool matches(std::string const &str) const;
+
+  private:
+    std::string           normaliseString(std::string const &str) const;
+    CaseSensitive::Choice m_caseSensitivity;
+    WildcardPosition      m_wildcard = NoWildcard;
+    std::string           m_pattern;
+  };
+} // namespace Catch
 
 // end catch_wildcard_pattern.h
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
 
 namespace Catch {
 
-    struct IConfig;
-
-    class TestSpec {
-        class Pattern {
-        public:
-            explicit Pattern( std::string const& name );
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-            std::string const& name() const;
-        private:
-            std::string const m_name;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            explicit NamePattern( std::string const& name, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            explicit TagPattern( std::string const& tag, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
+  struct IConfig;
 
-        class ExcludedPattern : public Pattern {
-        public:
-            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
+  class TestSpec
+  {
+    class Pattern
+    {
+    public:
+      explicit Pattern(std::string const &name);
+      virtual ~Pattern();
+      virtual bool       matches(TestCaseInfo const &testCase) const = 0;
+      std::string const &name() const;
+
+    private:
+      std::string const m_name;
+    };
+    using PatternPtr = std::shared_ptr<Pattern>;
 
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
+    class NamePattern : public Pattern
+    {
+    public:
+      explicit NamePattern(std::string const &name, std::string const &filterString);
+      bool matches(TestCaseInfo const &testCase) const override;
 
-            bool matches( TestCaseInfo const& testCase ) const;
-            std::string name() const;
-        };
+    private:
+      WildcardPattern m_wildcardPattern;
+    };
 
+    class TagPattern : public Pattern
+    {
     public:
-        struct FilterMatch {
-            std::string name;
-            std::vector<TestCase const*> tests;
-        };
-        using Matches = std::vector<FilterMatch>;
+      explicit TagPattern(std::string const &tag, std::string const &filterString);
+      bool matches(TestCaseInfo const &testCase) const override;
 
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+    private:
+      std::string m_tag;
+    };
+
+    class ExcludedPattern : public Pattern
+    {
+    public:
+      explicit ExcludedPattern(PatternPtr const &underlyingPattern);
+      bool matches(TestCaseInfo const &testCase) const override;
 
     private:
-        std::vector<Filter> m_filters;
+      PatternPtr m_underlyingPattern;
+    };
+
+    struct Filter
+    {
+      std::vector<PatternPtr> m_patterns;
 
-        friend class TestSpecParser;
+      bool        matches(TestCaseInfo const &testCase) const;
+      std::string name() const;
     };
-}
+
+  public:
+    struct FilterMatch
+    {
+      std::string                   name;
+      std::vector<TestCase const *> tests;
+    };
+    using Matches       = std::vector<FilterMatch>;
+    using vectorStrings = std::vector<std::string>;
+
+    bool    hasFilters() const;
+    bool    matches(TestCaseInfo const &testCase) const;
+    Matches matchesByFilter(std::vector<TestCase> const &testCases, IConfig const &config) const;
+    const vectorStrings &getInvalidArgs() const;
+
+  private:
+    std::vector<Filter>      m_filters;
+    std::vector<std::string> m_invalidArgs;
+    friend class TestSpecParser;
+  };
+} // namespace Catch
 
 #ifdef __clang__
 #pragma clang diagnostic pop
@@ -4988,76 +5746,89 @@ namespace Catch {
 
 namespace Catch {
 
-    struct TagAlias;
+  struct TagAlias;
 
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+  struct ITagAliasRegistry
+  {
+    virtual ~ITagAliasRegistry();
+    // Nullptr if not present
+    virtual TagAlias const *find(std::string const &alias) const                       = 0;
+    virtual std::string     expandAliases(std::string const &unexpandedTestSpec) const = 0;
 
-        static ITagAliasRegistry const& get();
-    };
+    static ITagAliasRegistry const &get();
+  };
 
 } // end namespace Catch
 
 // end catch_interfaces_tag_alias_registry.h
 namespace Catch {
 
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        bool m_exclusion = false;
-        std::size_t m_pos = 0;
-        std::string m_arg;
-        std::string m_substring;
-        std::string m_patternName;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        void visitChar( char c );
-        void startNewMode( Mode mode );
-        bool processNoneChar( char c );
-        void processNameChar( char c );
-        bool processOtherChar( char c );
-        void endMode();
-        void escape();
-        bool isControlChar( char c ) const;
-
-        template<typename T>
-        void addPattern() {
-            std::string token = m_patternName;
-            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i] - i ) + token.substr( m_escapeChars[i] -i +1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
-            }
-            if( !token.empty() ) {
-                TestSpec::PatternPtr pattern = std::make_shared<T>( token, m_substring );
-                if( m_exclusion )
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_substring.clear();
-            m_patternName.clear();
-            m_exclusion = false;
-            m_mode = None;
-        }
-
-        void addFilter();
-    };
-    TestSpec parseTestSpec( std::string const& arg );
+  class TestSpecParser
+  {
+    enum Mode { None, Name, QuotedName, Tag, EscapedName };
+    Mode                     m_mode           = None;
+    Mode                     lastMode         = None;
+    bool                     m_exclusion      = false;
+    std::size_t              m_pos            = 0;
+    std::size_t              m_realPatternPos = 0;
+    std::string              m_arg;
+    std::string              m_substring;
+    std::string              m_patternName;
+    std::vector<std::size_t> m_escapeChars;
+    TestSpec::Filter         m_currentFilter;
+    TestSpec                 m_testSpec;
+    ITagAliasRegistry const *m_tagAliases = nullptr;
+
+  public:
+    TestSpecParser(ITagAliasRegistry const &tagAliases);
+
+    TestSpecParser &parse(std::string const &arg);
+    TestSpec        testSpec();
+
+  private:
+    bool visitChar(char c);
+    void startNewMode(Mode mode);
+    bool processNoneChar(char c);
+    void processNameChar(char c);
+    bool processOtherChar(char c);
+    void endMode();
+    void escape();
+    bool isControlChar(char c) const;
+    void saveLastMode();
+    void revertBackToLastMode();
+    void addFilter();
+    bool separate();
+
+    template <typename T> void addPattern()
+    {
+      std::string token = m_patternName;
+      for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+        token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+      m_escapeChars.clear();
+      if (startsWith(token, "exclude:")) {
+        m_exclusion = true;
+        token       = token.substr(8);
+      }
+      if (!token.empty()) {
+        TestSpec::PatternPtr pattern = std::make_shared<T>(token, m_substring);
+        if (m_exclusion)
+          pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+        m_currentFilter.m_patterns.push_back(pattern);
+      }
+      m_substring.clear();
+      m_patternName.clear();
+      m_exclusion = false;
+      m_mode      = None;
+    }
+
+    inline void addCharToPattern(char c)
+    {
+      m_substring += c;
+      m_patternName += c;
+      m_realPatternPos++;
+    }
+  };
+  TestSpec parseTestSpec(std::string const &arg);
 
 } // namespace Catch
 
@@ -5069,8 +5840,8 @@ namespace Catch {
 // Libstdc++ doesn't like incomplete classes for unique_ptr
 
 #include <memory>
-#include <vector>
 #include <string>
+#include <vector>
 
 #ifndef CATCH_CONFIG_CONSOLE_WIDTH
 #define CATCH_CONFIG_CONSOLE_WIDTH 80
@@ -5078,104 +5849,104 @@ namespace Catch {
 
 namespace Catch {
 
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100000;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
+  struct IStream;
+
+  struct ConfigData
+  {
+    bool listTests         = false;
+    bool listTags          = false;
+    bool listReporters     = false;
+    bool listTestNamesOnly = false;
+
+    bool showSuccessfulTests = false;
+    bool shouldDebugBreak    = false;
+    bool noThrow             = false;
+    bool showHelp            = false;
+    bool showInvisibles      = false;
+    bool filenamesAsTags     = false;
+    bool libIdentify         = false;
+
+    int          abortAfter = -1;
+    unsigned int rngSeed    = 0;
+
+    bool         benchmarkNoAnalysis         = false;
+    unsigned int benchmarkSamples            = 100;
+    double       benchmarkConfidenceInterval = 0.95;
+    unsigned int benchmarkResamples          = 100000;
+
+    Verbosity             verbosity       = Verbosity::Normal;
+    WarnAbout::What       warnings        = WarnAbout::Nothing;
+    ShowDurations::OrNot  showDurations   = ShowDurations::DefaultForReporter;
+    RunTests::InWhatOrder runOrder        = RunTests::InDeclarationOrder;
+    UseColour::YesOrNo    useColour       = UseColour::Auto;
+    WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+    std::string outputFilename;
+    std::string name;
+    std::string processName;
 #ifndef CATCH_CONFIG_DEFAULT_REPORTER
 #define CATCH_CONFIG_DEFAULT_REPORTER "console"
 #endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+    std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
 #undef CATCH_CONFIG_DEFAULT_REPORTER
 
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
+    std::vector<std::string> testsOrTags;
+    std::vector<std::string> sectionsToRun;
+  };
 
-    class Config : public IConfig {
-    public:
+  class Config : public IConfig
+  {
+  public:
+    Config() = default;
+    Config(ConfigData const &data);
+    virtual ~Config() = default;
 
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
-
-        std::string const& getFilename() const;
-
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
-
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool benchmarkNoAnalysis() const override;
-        int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
+    std::string const &getFilename() const;
 
-    private:
+    bool listTests() const;
+    bool listTestNamesOnly() const;
+    bool listTags() const;
+    bool listReporters() const;
 
-        IStream const* openStream();
-        ConfigData m_data;
+    std::string        getProcessName() const;
+    std::string const &getReporterName() const;
 
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
+    std::vector<std::string> const &getTestsOrTags() const override;
+    std::vector<std::string> const &getSectionsToRun() const override;
+
+    TestSpec const &testSpec() const override;
+    bool            hasTestFilters() const override;
+
+    bool showHelp() const;
+
+    // IConfig interface
+    bool                  allowThrows() const override;
+    std::ostream &        stream() const override;
+    std::string           name() const override;
+    bool                  includeSuccessfulResults() const override;
+    bool                  warnAboutMissingAssertions() const override;
+    bool                  warnAboutNoTests() const override;
+    ShowDurations::OrNot  showDurations() const override;
+    RunTests::InWhatOrder runOrder() const override;
+    unsigned int          rngSeed() const override;
+    UseColour::YesOrNo    useColour() const override;
+    bool                  shouldDebugBreak() const override;
+    int                   abortAfter() const override;
+    bool                  showInvisibles() const override;
+    Verbosity             verbosity() const override;
+    bool                  benchmarkNoAnalysis() const override;
+    int                   benchmarkSamples() const override;
+    double                benchmarkConfidenceInterval() const override;
+    unsigned int          benchmarkResamples() const override;
+
+  private:
+    IStream const *openStream();
+    ConfigData     m_data;
+
+    std::unique_ptr<IStream const> m_stream;
+    TestSpec                       m_testSpec;
+    bool                           m_hasTestFilters = false;
+  };
 
 } // end namespace Catch
 
@@ -5186,42 +5957,43 @@ namespace Catch {
 
 namespace Catch {
 
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
+  struct AssertionResultData
+  {
+    AssertionResultData() = delete;
+
+    AssertionResultData(ResultWas::OfType _resultType, LazyExpression const &_lazyExpression);
+
+    std::string         message;
+    mutable std::string reconstructedExpression;
+    LazyExpression      lazyExpression;
+    ResultWas::OfType   resultType;
+
+    std::string reconstructExpression() const;
+  };
+
+  class AssertionResult
+  {
+  public:
+    AssertionResult() = delete;
+    AssertionResult(AssertionInfo const &info, AssertionResultData const &data);
+
+    bool              isOk() const;
+    bool              succeeded() const;
+    ResultWas::OfType getResultType() const;
+    bool              hasExpression() const;
+    bool              hasMessage() const;
+    std::string       getExpression() const;
+    std::string       getExpressionInMacro() const;
+    bool              hasExpandedExpression() const;
+    std::string       getExpandedExpression() const;
+    std::string       getMessage() const;
+    SourceLineInfo    getSourceInfo() const;
+    StringRef         getTestMacroName() const;
+
+    // protected:
+    AssertionInfo       m_info;
+    AssertionResultData m_resultData;
+  };
 
 } // end namespace Catch
 
@@ -5229,24 +6001,23 @@ namespace Catch {
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
 // start catch_estimate.hpp
 
- // Statistics estimates
-
+// Statistics estimates
 
 namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct Estimate {
-            Duration point;
-            Duration lower_bound;
-            Duration upper_bound;
-            double confidence_interval;
-
-            template <typename Duration2>
-            operator Estimate<Duration2>() const {
-                return { point, lower_bound, upper_bound, confidence_interval };
-            }
-        };
-    } // namespace Benchmark
+  namespace Benchmark {
+    template <typename Duration> struct Estimate
+    {
+      Duration point;
+      Duration lower_bound;
+      Duration upper_bound;
+      double   confidence_interval;
+
+      template <typename Duration2> operator Estimate<Duration2>() const
+      {
+        return {point, lower_bound, upper_bound, confidence_interval};
+      }
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_estimate.hpp
@@ -5255,527 +6026,536 @@ namespace Catch {
 // Outlier information
 
 namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
+  namespace Benchmark {
+    struct OutlierClassification
+    {
+      int samples_seen = 0;
+      int low_severe   = 0; // more than 3 times IQR below Q1
+      int low_mild     = 0; // 1.5 to 3 times IQR below Q1
+      int high_mild    = 0; // 1.5 to 3 times IQR above Q3
+      int high_severe  = 0; // more than 3 times IQR above Q3
+
+      int total() const { return low_severe + low_mild + high_mild + high_severe; }
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_outlier_classification.hpp
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-#include <string>
+#include <algorithm>
 #include <iosfwd>
 #include <map>
-#include <set>
 #include <memory>
-#include <algorithm>
+#include <set>
+#include <string>
 
 namespace Catch {
 
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
+  struct ReporterConfig
+  {
+    explicit ReporterConfig(IConfigPtr const &_fullConfig);
 
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
+    ReporterConfig(IConfigPtr const &_fullConfig, std::ostream &_stream);
 
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
+    std::ostream &stream() const;
+    IConfigPtr    fullConfig() const;
 
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
+  private:
+    std::ostream *m_stream;
+    IConfigPtr    m_fullConfig;
+  };
 
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
+  struct ReporterPreferences
+  {
+    bool shouldRedirectStdOut      = false;
+    bool shouldReportAllAssertions = false;
+  };
 
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
+  template <typename T> struct LazyStat : Option<T>
+  {
+    LazyStat &operator=(T const &_value)
+    {
+      Option<T>::operator=(_value);
+      used               = false;
+      return *this;
+    }
+    void reset()
+    {
+      Option<T>::reset();
+      used = false;
+    }
+    bool used = false;
+  };
 
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
+  struct TestRunInfo
+  {
+    TestRunInfo(std::string const &_name);
+    std::string name;
+  };
+  struct GroupInfo
+  {
+    GroupInfo(std::string const &_name, std::size_t _groupIndex, std::size_t _groupsCount);
 
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
+    std::string name;
+    std::size_t groupIndex;
+    std::size_t groupsCounts;
+  };
+
+  struct AssertionStats
+  {
+    AssertionStats(AssertionResult const &         _assertionResult,
+                   std::vector<MessageInfo> const &_infoMessages, Totals const &_totals);
+
+    AssertionStats(AssertionStats const &) = default;
+    AssertionStats(AssertionStats &&)      = default;
+    AssertionStats &operator=(AssertionStats const &) = delete;
+    AssertionStats &operator=(AssertionStats &&) = delete;
+    virtual ~AssertionStats();
+
+    AssertionResult          assertionResult;
+    std::vector<MessageInfo> infoMessages;
+    Totals                   totals;
+  };
+
+  struct SectionStats
+  {
+    SectionStats(SectionInfo const &_sectionInfo, Counts const &_assertions,
+                 double _durationInSeconds, bool _missingAssertions);
+    SectionStats(SectionStats const &) = default;
+    SectionStats(SectionStats &&)      = default;
+    SectionStats &operator=(SectionStats const &) = default;
+    SectionStats &operator=(SectionStats &&) = default;
+    virtual ~SectionStats();
+
+    SectionInfo sectionInfo;
+    Counts      assertions;
+    double      durationInSeconds;
+    bool        missingAssertions;
+  };
+
+  struct TestCaseStats
+  {
+    TestCaseStats(TestCaseInfo const &_testInfo, Totals const &_totals, std::string const &_stdOut,
+                  std::string const &_stdErr, bool _aborting);
+
+    TestCaseStats(TestCaseStats const &) = default;
+    TestCaseStats(TestCaseStats &&)      = default;
+    TestCaseStats &operator=(TestCaseStats const &) = default;
+    TestCaseStats &operator=(TestCaseStats &&) = default;
+    virtual ~TestCaseStats();
+
+    TestCaseInfo testInfo;
+    Totals       totals;
+    std::string  stdOut;
+    std::string  stdErr;
+    bool         aborting;
+  };
+
+  struct TestGroupStats
+  {
+    TestGroupStats(GroupInfo const &_groupInfo, Totals const &_totals, bool _aborting);
+    TestGroupStats(GroupInfo const &_groupInfo);
+
+    TestGroupStats(TestGroupStats const &) = default;
+    TestGroupStats(TestGroupStats &&)      = default;
+    TestGroupStats &operator=(TestGroupStats const &) = default;
+    TestGroupStats &operator=(TestGroupStats &&) = default;
+    virtual ~TestGroupStats();
+
+    GroupInfo groupInfo;
+    Totals    totals;
+    bool      aborting;
+  };
+
+  struct TestRunStats
+  {
+    TestRunStats(TestRunInfo const &_runInfo, Totals const &_totals, bool _aborting);
+
+    TestRunStats(TestRunStats const &) = default;
+    TestRunStats(TestRunStats &&)      = default;
+    TestRunStats &operator=(TestRunStats const &) = default;
+    TestRunStats &operator=(TestRunStats &&) = default;
+    virtual ~TestRunStats();
+
+    TestRunInfo runInfo;
+    Totals      totals;
+    bool        aborting;
+  };
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-            return {
-                info,
-                std::move(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
+  struct BenchmarkInfo
+  {
+    std::string  name;
+    double       estimatedDuration;
+    int          iterations;
+    int          samples;
+    unsigned int resamples;
+    double       clockResolution;
+    double       clockCost;
+  };
+
+  template <class Duration> struct BenchmarkStats
+  {
+    BenchmarkInfo info;
+
+    std::vector<Duration>            samples;
+    Benchmark::Estimate<Duration>    mean;
+    Benchmark::Estimate<Duration>    standardDeviation;
+    Benchmark::OutlierClassification outliers;
+    double                           outlierVariance;
+
+    template <typename Duration2> operator BenchmarkStats<Duration2>() const
+    {
+      std::vector<Duration2> samples2;
+      samples2.reserve(samples.size());
+      std::transform(samples.begin(), samples.end(), std::back_inserter(samples2),
+                     [](Duration d) { return Duration2(d); });
+      return {
+          info, std::move(samples2), mean, standardDeviation, outliers, outlierVariance,
+      };
+    }
+  };
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
+  struct IStreamingReporter
+  {
+    virtual ~IStreamingReporter() = default;
 
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
+    // Implementing class must also provide the following static methods:
+    // static std::string getDescription();
+    // static std::set<Verbosity> getSupportedVerbosities()
 
-        virtual ReporterPreferences getPreferences() const = 0;
+    virtual ReporterPreferences getPreferences() const = 0;
 
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+    virtual void noMatchingTestCases(std::string const &spec) = 0;
 
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+    virtual void reportInvalidArguments(std::string const &) {}
 
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+    virtual void testRunStarting(TestRunInfo const &testRunInfo) = 0;
+    virtual void testGroupStarting(GroupInfo const &groupInfo)   = 0;
+
+    virtual void testCaseStarting(TestCaseInfo const &testInfo)  = 0;
+    virtual void sectionStarting(SectionInfo const &sectionInfo) = 0;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& ) {}
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
-        virtual void benchmarkFailed( std::string const& ) {}
+    virtual void benchmarkPreparing(std::string const &) {}
+    virtual void benchmarkStarting(BenchmarkInfo const &) {}
+    virtual void benchmarkEnded(BenchmarkStats<> const &) {}
+    virtual void benchmarkFailed(std::string const &) {}
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
+    virtual void assertionStarting(AssertionInfo const &assertionInfo) = 0;
 
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
+    // The return value indicates if the messages buffer should be cleared:
+    virtual bool assertionEnded(AssertionStats const &assertionStats) = 0;
+
+    virtual void sectionEnded(SectionStats const &sectionStats)       = 0;
+    virtual void testCaseEnded(TestCaseStats const &testCaseStats)    = 0;
+    virtual void testGroupEnded(TestGroupStats const &testGroupStats) = 0;
+    virtual void testRunEnded(TestRunStats const &testRunStats)       = 0;
+
+    virtual void skipTest(TestCaseInfo const &testInfo) = 0;
+
+    // Default empty implementation provided
+    virtual void fatalErrorEncountered(StringRef name);
+
+    virtual bool isMulti() const;
+  };
+  using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+  struct IReporterFactory
+  {
+    virtual ~IReporterFactory();
+    virtual IStreamingReporterPtr create(ReporterConfig const &config) const = 0;
+    virtual std::string           getDescription() const                     = 0;
+  };
+  using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+  struct IReporterRegistry
+  {
+    using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+    using Listeners  = std::vector<IReporterFactoryPtr>;
+
+    virtual ~IReporterRegistry();
+    virtual IStreamingReporterPtr create(std::string const &name,
+                                         IConfigPtr const & config) const = 0;
+    virtual FactoryMap const &    getFactories() const                   = 0;
+    virtual Listeners const &     getListeners() const                   = 0;
+  };
 
 } // end namespace Catch
 
 // end catch_interfaces_reporter.h
 #include <algorithm>
-#include <cstring>
+#include <cassert>
 #include <cfloat>
 #include <cstdio>
-#include <cassert>
+#include <cstring>
 #include <memory>
 #include <ostream>
 
 namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
+  void prepareExpandedExpression(AssertionResult &result);
 
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
+  // Returns double formatted as %.3f (format expected on output)
+  std::string getFormattedDuration(double duration);
 
-    std::string serializeFilters( std::vector<std::string> const& container );
+  std::string serializeFilters(std::vector<std::string> const &container);
 
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
+  template <typename DerivedT> struct StreamingReporterBase : IStreamingReporter
+  {
 
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
+    StreamingReporterBase(ReporterConfig const &_config)
+        : m_config(_config.fullConfig()), stream(_config.stream())
+    {
+      m_reporterPrefs.shouldRedirectStdOut = false;
+      if (!DerivedT::getSupportedVerbosities().count(m_config->verbosity()))
+        CATCH_ERROR("Verbosity level not supported by this reporter");
+    }
 
-        ~StreamingReporterBase() override = default;
+    ReporterPreferences getPreferences() const override { return m_reporterPrefs; }
 
-        void noMatchingTestCases(std::string const&) override {}
+    static std::set<Verbosity> getSupportedVerbosities() { return {Verbosity::Normal}; }
 
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
+    ~StreamingReporterBase() override = default;
 
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
+    void noMatchingTestCases(std::string const &) override {}
 
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
+    void reportInvalidArguments(std::string const &) override {}
 
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
+    void testRunStarting(TestRunInfo const &_testRunInfo) override
+    {
+      currentTestRunInfo = _testRunInfo;
+    }
 
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
+    void testGroupStarting(GroupInfo const &_groupInfo) override { currentGroupInfo = _groupInfo; }
 
-        IConfigPtr m_config;
-        std::ostream& stream;
+    void testCaseStarting(TestCaseInfo const &_testInfo) override
+    {
+      currentTestCaseInfo = _testInfo;
+    }
+    void sectionStarting(SectionInfo const &_sectionInfo) override
+    {
+      m_sectionStack.push_back(_sectionInfo);
+    }
 
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
+    void sectionEnded(SectionStats const & /* _sectionStats */) override
+    {
+      m_sectionStack.pop_back();
+    }
+    void testCaseEnded(TestCaseStats const & /* _testCaseStats */) override
+    {
+      currentTestCaseInfo.reset();
+    }
+    void testGroupEnded(TestGroupStats const & /* _testGroupStats */) override
+    {
+      currentGroupInfo.reset();
+    }
+    void testRunEnded(TestRunStats const & /* _testRunStats */) override
+    {
+      currentTestCaseInfo.reset();
+      currentGroupInfo.reset();
+      currentTestRunInfo.reset();
+    }
 
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
+    void skipTest(TestCaseInfo const &) override
+    {
+      // Don't do anything with this by default.
+      // It can optionally be overridden in the derived class.
+    }
 
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
+    IConfigPtr    m_config;
+    std::ostream &stream;
 
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
+    LazyStat<TestRunInfo>  currentTestRunInfo;
+    LazyStat<GroupInfo>    currentGroupInfo;
+    LazyStat<TestCaseInfo> currentTestCaseInfo;
 
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
+    std::vector<SectionInfo> m_sectionStack;
+    ReporterPreferences      m_reporterPrefs;
+  };
 
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
+  template <typename DerivedT> struct CumulativeReporterBase : IStreamingReporter
+  {
+    template <typename T, typename ChildNodeT> struct Node
+    {
+      explicit Node(T const &_value) : value(_value) {}
+      virtual ~Node() {}
 
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
+      using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+      T          value;
+      ChildNodes children;
+    };
+    struct SectionNode
+    {
+      explicit SectionNode(SectionStats const &_stats) : stats(_stats) {}
+      virtual ~SectionNode() = default;
+
+      bool operator==(SectionNode const &other) const
+      {
+        return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+      }
+      bool operator==(std::shared_ptr<SectionNode> const &other) const
+      {
+        return operator==(*other);
+      }
+
+      SectionStats stats;
+      using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+      using Assertions    = std::vector<AssertionStats>;
+      ChildSections childSections;
+      Assertions    assertions;
+      std::string   stdOut;
+      std::string   stdErr;
+    };
 
-        private:
-            SectionInfo const& m_other;
-        };
+    struct BySectionInfo
+    {
+      BySectionInfo(SectionInfo const &other) : m_other(other) {}
+      BySectionInfo(BySectionInfo const &other) : m_other(other.m_other) {}
+      bool operator()(std::shared_ptr<SectionNode> const &node) const
+      {
+        return ((node->stats.sectionInfo.name == m_other.name) &&
+                (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+      }
+      void operator=(BySectionInfo const &) = delete;
 
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+    private:
+      SectionInfo const &m_other;
+    };
 
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
+    using TestCaseNode  = Node<TestCaseStats, SectionNode>;
+    using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+    using TestRunNode   = Node<TestRunStats, TestGroupNode>;
 
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
+    CumulativeReporterBase(ReporterConfig const &_config)
+        : m_config(_config.fullConfig()), stream(_config.stream())
+    {
+      m_reporterPrefs.shouldRedirectStdOut = false;
+      if (!DerivedT::getSupportedVerbosities().count(m_config->verbosity()))
+        CATCH_ERROR("Verbosity level not supported by this reporter");
+    }
+    ~CumulativeReporterBase() override = default;
 
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
+    ReporterPreferences getPreferences() const override { return m_reporterPrefs; }
 
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
+    static std::set<Verbosity> getSupportedVerbosities() { return {Verbosity::Normal}; }
 
-        void testCaseStarting( TestCaseInfo const& ) override {}
+    void testRunStarting(TestRunInfo const &) override {}
+    void testGroupStarting(GroupInfo const &) override {}
 
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
+    void testCaseStarting(TestCaseInfo const &) override {}
 
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
+    void sectionStarting(SectionInfo const &sectionInfo) override
+    {
+      SectionStats                 incompleteStats(sectionInfo, Counts(), 0, false);
+      std::shared_ptr<SectionNode> node;
+      if (m_sectionStack.empty()) {
+        if (!m_rootSection)
+          m_rootSection = std::make_shared<SectionNode>(incompleteStats);
+        node = m_rootSection;
+      }
+      else {
+        SectionNode &parentNode = *m_sectionStack.back();
+        auto it = std::find_if(parentNode.childSections.begin(), parentNode.childSections.end(),
+                               BySectionInfo(sectionInfo));
+        if (it == parentNode.childSections.end()) {
+          node = std::make_shared<SectionNode>(incompleteStats);
+          parentNode.childSections.push_back(node);
         }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+        else
+          node = *it;
+      }
+      m_sectionStack.push_back(node);
+      m_deepestSection = std::move(node);
+    }
 
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+    void assertionStarting(AssertionInfo const &) override {}
 
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
+    bool assertionEnded(AssertionStats const &assertionStats) override
+    {
+      assert(!m_sectionStack.empty());
+      // AssertionResult holds a pointer to a temporary DecomposedExpression,
+      // which getExpandedExpression() calls to build the expression string.
+      // Our section stack copy of the assertionResult will likely outlive the
+      // temporary, so it must be expanded or discarded now to avoid calling
+      // a destroyed object later.
+      prepareExpandedExpression(const_cast<AssertionResult &>(assertionStats.assertionResult));
+      SectionNode &sectionNode = *m_sectionStack.back();
+      sectionNode.assertions.push_back(assertionStats);
+      return true;
+    }
+    void sectionEnded(SectionStats const &sectionStats) override
+    {
+      assert(!m_sectionStack.empty());
+      SectionNode &node = *m_sectionStack.back();
+      node.stats        = sectionStats;
+      m_sectionStack.pop_back();
+    }
+    void testCaseEnded(TestCaseStats const &testCaseStats) override
+    {
+      auto node = std::make_shared<TestCaseNode>(testCaseStats);
+      assert(m_sectionStack.size() == 0);
+      node->children.push_back(m_rootSection);
+      m_testCases.push_back(node);
+      m_rootSection.reset();
 
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
+      assert(m_deepestSection);
+      m_deepestSection->stdOut = testCaseStats.stdOut;
+      m_deepestSection->stdErr = testCaseStats.stdErr;
+    }
+    void testGroupEnded(TestGroupStats const &testGroupStats) override
+    {
+      auto node = std::make_shared<TestGroupNode>(testGroupStats);
+      node->children.swap(m_testCases);
+      m_testGroups.push_back(node);
     }
+    void testRunEnded(TestRunStats const &testRunStats) override
+    {
+      auto node = std::make_shared<TestRunNode>(testRunStats);
+      node->children.swap(m_testGroups);
+      m_testRuns.push_back(node);
+      testRunEndedCumulative();
+    }
+    virtual void testRunEndedCumulative() = 0;
+
+    void skipTest(TestCaseInfo const &) override {}
+
+    IConfigPtr                                             m_config;
+    std::ostream &                                         stream;
+    std::vector<AssertionStats>                            m_assertions;
+    std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+    std::vector<std::shared_ptr<TestCaseNode>>             m_testCases;
+    std::vector<std::shared_ptr<TestGroupNode>>            m_testGroups;
+
+    std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+    std::shared_ptr<SectionNode>              m_rootSection;
+    std::shared_ptr<SectionNode>              m_deepestSection;
+    std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+    ReporterPreferences                       m_reporterPrefs;
+  };
+
+  template <char C> char const *getLineOfChars()
+  {
+    static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+    if (!*line) {
+      std::memset(line, C, CATCH_CONFIG_CONSOLE_WIDTH - 1);
+      line[CATCH_CONFIG_CONSOLE_WIDTH - 1] = 0;
+    }
+    return line;
+  }
 
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
+  struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase>
+  {
+    TestEventListenerBase(ReporterConfig const &_config);
 
-        static std::set<Verbosity> getSupportedVerbosities();
+    static std::set<Verbosity> getSupportedVerbosities();
 
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
+    void assertionStarting(AssertionInfo const &) override;
+    bool assertionEnded(AssertionStats const &) override;
+  };
 
 } // end namespace Catch
 
@@ -5784,119 +6564,123 @@ namespace Catch {
 
 namespace Catch {
 
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
+  struct Colour
+  {
+    enum Code {
+      None = 0,
+
+      White,
+      Red,
+      Green,
+      Blue,
+      Cyan,
+      Yellow,
+      Grey,
+
+      Bright = 0x10,
+
+      BrightRed    = Bright | Red,
+      BrightGreen  = Bright | Green,
+      LightGrey    = Bright | Grey,
+      BrightWhite  = Bright | White,
+      BrightYellow = Bright | Yellow,
+
+      // By intention
+      FileName              = LightGrey,
+      Warning               = BrightYellow,
+      ResultError           = BrightRed,
+      ResultSuccess         = BrightGreen,
+      ResultExpectedFailure = Warning,
+
+      Error   = BrightRed,
+      Success = Green,
+
+      OriginalExpression      = Cyan,
+      ReconstructedExpression = BrightYellow,
+
+      SecondaryText = LightGrey,
+      Headers       = White
+    };
 
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
+    // Use constructed object for RAII guard
+    Colour(Code _colourCode);
+    Colour(Colour &&other) noexcept;
+    Colour &operator=(Colour &&other) noexcept;
+    ~Colour();
 
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
+    // Use static method for one-shot changes
+    static void use(Code _colourCode);
 
-    private:
-        bool m_moved = false;
-    };
+  private:
+    bool m_moved = false;
+  };
 
-    std::ostream& operator << ( std::ostream& os, Colour const& );
+  std::ostream &operator<<(std::ostream &os, Colour const &);
 
 } // end namespace Catch
 
 // end catch_console_colour.h
 // start catch_reporter_registrars.hpp
 
-
 namespace Catch {
 
-    template<typename T>
-    class ReporterRegistrar {
+  template <typename T> class ReporterRegistrar
+  {
 
-        class ReporterFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-
-            std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
+    class ReporterFactory : public IReporterFactory
+    {
 
-    public:
+      IStreamingReporterPtr create(ReporterConfig const &config) const override
+      {
+        return std::unique_ptr<T>(new T(config));
+      }
 
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
+      std::string getDescription() const override { return T::getDescription(); }
     };
 
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public IReporterFactory {
+  public:
+    explicit ReporterRegistrar(std::string const &name)
+    {
+      getMutableRegistryHub().registerReporter(name, std::make_shared<ReporterFactory>());
+    }
+  };
 
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            std::string getDescription() const override {
-                return std::string();
-            }
-        };
+  template <typename T> class ListenerRegistrar
+  {
 
-    public:
+    class ListenerFactory : public IReporterFactory
+    {
 
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
+      IStreamingReporterPtr create(ReporterConfig const &config) const override
+      {
+        return std::unique_ptr<T>(new T(config));
+      }
+      std::string getDescription() const override { return std::string(); }
     };
-}
 
-#if !defined(CATCH_CONFIG_DISABLE)
+  public:
+    ListenerRegistrar()
+    {
+      getMutableRegistryHub().registerListener(std::make_shared<ListenerFactory>());
+    }
+  };
+} // namespace Catch
 
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+#if !defined(CATCH_CONFIG_DISABLE)
 
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS   \
-     namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#define CATCH_REGISTER_REPORTER(name, reporterType)                                                \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType(name);        \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+
+#define CATCH_REGISTER_LISTENER(listenerType)                                                      \
+  CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                                                         \
+  namespace {                                                                                      \
+    Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType;              \
+  }                                                                                                \
+  CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 #else // CATCH_CONFIG_DISABLE
 
 #define CATCH_REGISTER_REPORTER(name, reporterType)
@@ -5910,27 +6694,27 @@ namespace Catch {
 
 namespace Catch {
 
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
+  struct CompactReporter : StreamingReporterBase<CompactReporter>
+  {
 
-        ~CompactReporter() override;
+    using StreamingReporterBase::StreamingReporterBase;
 
-        static std::string getDescription();
+    ~CompactReporter() override;
 
-        ReporterPreferences getPreferences() const override;
+    static std::string getDescription();
 
-        void noMatchingTestCases(std::string const& spec) override;
+    ReporterPreferences getPreferences() const override;
 
-        void assertionStarting(AssertionInfo const&) override;
+    void noMatchingTestCases(std::string const &spec) override;
 
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
+    void assertionStarting(AssertionInfo const &) override;
 
-        void sectionEnded(SectionStats const& _sectionStats) override;
+    bool assertionEnded(AssertionStats const &_assertionStats) override;
 
-        void testRunEnded(TestRunStats const& _testRunStats) override;
+    void sectionEnded(SectionStats const &_sectionStats) override;
 
-    };
+    void testRunEnded(TestRunStats const &_testRunStats) override;
+  };
 
 } // end namespace Catch
 
@@ -5939,69 +6723,73 @@ namespace Catch {
 
 #if defined(_MSC_VER)
 #pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
+#pragma warning(disable : 4061) // Not all labels are EXPLICITLY handled in switch
+                                // Note that 4062 (not all labels are handled
+                                // and default is missing) is enabled
 #endif
 
 namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
+  // Fwd decls
+  struct SummaryColumn;
+  class TablePrinter;
+
+  struct ConsoleReporter : StreamingReporterBase<ConsoleReporter>
+  {
+    std::unique_ptr<TablePrinter> m_tablePrinter;
 
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
+    ConsoleReporter(ReporterConfig const &config);
+    ~ConsoleReporter() override;
+    static std::string getDescription();
 
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
+    void noMatchingTestCases(std::string const &spec) override;
 
-        void noMatchingTestCases(std::string const& spec) override;
+    void reportInvalidArguments(std::string const &arg) override;
 
-        void assertionStarting(AssertionInfo const&) override;
+    void assertionStarting(AssertionInfo const &) override;
 
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
+    bool assertionEnded(AssertionStats const &_assertionStats) override;
 
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
+    void sectionStarting(SectionInfo const &_sectionInfo) override;
+    void sectionEnded(SectionStats const &_sectionStats) override;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed(std::string const& error) override;
+    void benchmarkPreparing(std::string const &name) override;
+    void benchmarkStarting(BenchmarkInfo const &info) override;
+    void benchmarkEnded(BenchmarkStats<> const &stats) override;
+    void benchmarkFailed(std::string const &error) override;
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-    private:
+    void testCaseEnded(TestCaseStats const &_testCaseStats) override;
+    void testGroupEnded(TestGroupStats const &_testGroupStats) override;
+    void testRunEnded(TestRunStats const &_testRunStats) override;
+    void testRunStarting(TestRunInfo const &_testRunInfo) override;
 
-        void lazyPrint();
+  private:
+    void lazyPrint();
 
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
+    void lazyPrintWithoutClosingBenchmarkTable();
+    void lazyPrintRunInfo();
+    void lazyPrintGroupInfo();
+    void printTestCaseAndSectionHeader();
 
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
+    void printClosedHeader(std::string const &_name);
+    void printOpenHeader(std::string const &_name);
 
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+    // if string has a : in first line will set indent to follow it on
+    // subsequent lines
+    void printHeaderString(std::string const &_string, std::size_t indent = 0);
 
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+    void printTotals(Totals const &totals);
+    void printSummaryRow(std::string const &label, std::vector<SummaryColumn> const &cols,
+                         std::size_t row);
 
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
-        void printTestFilters();
+    void printTotalsDivider(Totals const &totals);
+    void printSummaryDivider();
+    void printTestFilters();
 
-    private:
-        bool m_headerPrinted = false;
-    };
+  private:
+    bool m_headerPrinted = false;
+  };
 
 } // end namespace Catch
 
@@ -6018,137 +6806,139 @@ namespace Catch {
 
 namespace Catch {
 
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
+  class XmlEncode
+  {
+  public:
+    enum ForWhat { ForTextNodes, ForAttributes };
 
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+    XmlEncode(std::string const &str, ForWhat forWhat = ForTextNodes);
 
-        void encodeTo( std::ostream& os ) const;
+    void encodeTo(std::ostream &os) const;
 
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+    friend std::ostream &operator<<(std::ostream &os, XmlEncode const &xmlEncode);
 
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
+  private:
+    std::string m_str;
+    ForWhat     m_forWhat;
+  };
 
-    class XmlWriter {
+  class XmlWriter
+  {
+  public:
+    class ScopedElement
+    {
     public:
+      ScopedElement(XmlWriter *writer);
 
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
+      ScopedElement(ScopedElement &&other) noexcept;
+      ScopedElement &operator=(ScopedElement &&other) noexcept;
 
-            ScopedElement& writeText( std::string const& text, bool indent = true );
+      ~ScopedElement();
 
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
+      ScopedElement &writeText(std::string const &text, bool indent = true);
 
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-        };
+      template <typename T>
+      ScopedElement &writeAttribute(std::string const &name, T const &attribute)
+      {
+        m_writer->writeAttribute(name, attribute);
+        return *this;
+      }
 
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
+    private:
+      mutable XmlWriter *m_writer = nullptr;
+    };
 
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
+    XmlWriter(std::ostream &os = Catch::cout());
+    ~XmlWriter();
 
-        XmlWriter& startElement( std::string const& name );
+    XmlWriter(XmlWriter const &) = delete;
+    XmlWriter &operator=(XmlWriter const &) = delete;
 
-        ScopedElement scopedElement( std::string const& name );
+    XmlWriter &startElement(std::string const &name);
 
-        XmlWriter& endElement();
+    ScopedElement scopedElement(std::string const &name);
 
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+    XmlWriter &endElement();
 
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+    XmlWriter &writeAttribute(std::string const &name, std::string const &attribute);
 
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
+    XmlWriter &writeAttribute(std::string const &name, bool attribute);
 
-        XmlWriter& writeText( std::string const& text, bool indent = true );
+    template <typename T> XmlWriter &writeAttribute(std::string const &name, T const &attribute)
+    {
+      ReusableStringStream rss;
+      rss << attribute;
+      return writeAttribute(name, rss.str());
+    }
 
-        XmlWriter& writeComment( std::string const& text );
+    XmlWriter &writeText(std::string const &text, bool indent = true);
 
-        void writeStylesheetRef( std::string const& url );
+    XmlWriter &writeComment(std::string const &text);
 
-        XmlWriter& writeBlankLine();
+    void writeStylesheetRef(std::string const &url);
 
-        void ensureTagClosed();
+    XmlWriter &writeBlankLine();
 
-    private:
+    void ensureTagClosed();
 
-        void writeDeclaration();
+  private:
+    void writeDeclaration();
 
-        void newlineIfNecessary();
+    void newlineIfNecessary();
 
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
+    bool                     m_tagIsOpen    = false;
+    bool                     m_needsNewline = false;
+    std::vector<std::string> m_tags;
+    std::string              m_indent;
+    std::ostream &           m_os;
+  };
 
-}
+} // namespace Catch
 
 // end catch_xmlwriter.h
 namespace Catch {
 
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
+  class JunitReporter : public CumulativeReporterBase<JunitReporter>
+  {
+  public:
+    JunitReporter(ReporterConfig const &_config);
 
-        ~JunitReporter() override;
+    ~JunitReporter() override;
 
-        static std::string getDescription();
+    static std::string getDescription();
 
-        void noMatchingTestCases(std::string const& /*spec*/) override;
+    void noMatchingTestCases(std::string const & /*spec*/) override;
 
-        void testRunStarting(TestRunInfo const& runInfo) override;
+    void testRunStarting(TestRunInfo const &runInfo) override;
 
-        void testGroupStarting(GroupInfo const& groupInfo) override;
+    void testGroupStarting(GroupInfo const &groupInfo) override;
 
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
+    void testCaseStarting(TestCaseInfo const &testCaseInfo) override;
+    bool assertionEnded(AssertionStats const &assertionStats) override;
 
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+    void testCaseEnded(TestCaseStats const &testCaseStats) override;
 
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+    void testGroupEnded(TestGroupStats const &testGroupStats) override;
 
-        void testRunEndedCumulative() override;
+    void testRunEndedCumulative() override;
 
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+    void writeGroup(TestGroupNode const &groupNode, double suiteTime);
 
-        void writeTestCase(TestCaseNode const& testCaseNode);
+    void writeTestCase(TestCaseNode const &testCaseNode);
 
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
+    void writeSection(std::string const &className, std::string const &rootName,
+                      SectionNode const &sectionNode);
 
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
+    void writeAssertions(SectionNode const &sectionNode);
+    void writeAssertion(AssertionStats const &stats);
 
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
+    XmlWriter    xml;
+    Timer        suiteTimer;
+    std::string  stdOutForSuite;
+    std::string  stdErrForSuite;
+    unsigned int unexpectedExceptions = 0;
+    bool         m_okToFail           = false;
+  };
 
 } // end namespace Catch
 
@@ -6156,54 +6946,54 @@ namespace Catch {
 // start catch_reporter_xml.h
 
 namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
-
-        ~XmlReporter() override;
+  class XmlReporter : public StreamingReporterBase<XmlReporter>
+  {
+  public:
+    XmlReporter(ReporterConfig const &_config);
 
-        static std::string getDescription();
+    ~XmlReporter() override;
 
-        virtual std::string getStylesheetRef() const;
+    static std::string getDescription();
 
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+    virtual std::string getStylesheetRef() const;
 
-    public: // StreamingReporterBase
+    void writeSourceInfo(SourceLineInfo const &sourceInfo);
 
-        void noMatchingTestCases(std::string const& s) override;
+  public: // StreamingReporterBase
+    void noMatchingTestCases(std::string const &s) override;
 
-        void testRunStarting(TestRunInfo const& testInfo) override;
+    void testRunStarting(TestRunInfo const &testInfo) override;
 
-        void testGroupStarting(GroupInfo const& groupInfo) override;
+    void testGroupStarting(GroupInfo const &groupInfo) override;
 
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
+    void testCaseStarting(TestCaseInfo const &testInfo) override;
 
-        void sectionStarting(SectionInfo const& sectionInfo) override;
+    void sectionStarting(SectionInfo const &sectionInfo) override;
 
-        void assertionStarting(AssertionInfo const&) override;
+    void assertionStarting(AssertionInfo const &) override;
 
-        bool assertionEnded(AssertionStats const& assertionStats) override;
+    bool assertionEnded(AssertionStats const &assertionStats) override;
 
-        void sectionEnded(SectionStats const& sectionStats) override;
+    void sectionEnded(SectionStats const &sectionStats) override;
 
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+    void testCaseEnded(TestCaseStats const &testCaseStats) override;
 
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+    void testGroupEnded(TestGroupStats const &testGroupStats) override;
 
-        void testRunEnded(TestRunStats const& testRunStats) override;
+    void testRunEnded(TestRunStats const &testRunStats) override;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed(std::string const&) override;
+    void benchmarkPreparing(std::string const &name) override;
+    void benchmarkStarting(BenchmarkInfo const &) override;
+    void benchmarkEnded(BenchmarkStats<> const &) override;
+    void benchmarkFailed(std::string const &) override;
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
+  private:
+    Timer     m_testCaseTimer;
+    XmlWriter m_xml;
+    int       m_sectionDepth = 0;
+  };
 
 } // end namespace Catch
 
@@ -6215,102 +7005,89 @@ namespace Catch {
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
 // start catch_benchmark.hpp
 
- // Benchmark
+// Benchmark
 
 // start catch_chronometer.hpp
 
 // User-facing chronometer
 
-
 // start catch_clock.hpp
 
 // Clocks
 
-
 #include <chrono>
 #include <ratio>
 
 namespace Catch {
-    namespace Benchmark {
-        template <typename Clock>
-        using ClockDuration = typename Clock::duration;
-        template <typename Clock>
-        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+  namespace Benchmark {
+    template <typename Clock> using ClockDuration = typename Clock::duration;
+    template <typename Clock>
+    using FloatDuration = std::chrono::duration<double, typename Clock::period>;
 
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
+    template <typename Clock> using TimePoint = typename Clock::time_point;
 
-        using default_clock = std::chrono::steady_clock;
+    using default_clock = std::chrono::steady_clock;
 
-        template <typename Clock>
-        struct now {
-            TimePoint<Clock> operator()() const {
-                return Clock::now();
-            }
-        };
+    template <typename Clock> struct now
+    {
+      TimePoint<Clock> operator()() const { return Clock::now(); }
+    };
 
-        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
-    } // namespace Benchmark
+    using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_clock.hpp
 // start catch_optimizer.hpp
 
- // Hinting the optimizer
-
+// Hinting the optimizer
 
 #if defined(_MSC_VER)
-#   include <atomic> // atomic_thread_fence
+#include <atomic> // atomic_thread_fence
 #endif
 
 namespace Catch {
-    namespace Benchmark {
+  namespace Benchmark {
 #if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
+    template <typename T> inline void keep_memory(T *p) { asm volatile("" : : "g"(p) : "memory"); }
+    inline void                       keep_memory() { asm volatile("" : : : "memory"); }
 
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
+    namespace Detail {
+      inline void optimizer_barrier() { keep_memory(); }
+    } // namespace Detail
 #elif defined(_MSC_VER)
 
 #pragma optimize("", off)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
+    template <typename T> inline void keep_memory(T *p)
+    {
+      // thanks @milleniumbug
+      *reinterpret_cast<char volatile *>(p) = *reinterpret_cast<char const volatile *>(p);
+    }
+    // TODO equivalent keep_memory()
 #pragma optimize("", on)
 
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
+    namespace Detail {
+      inline void optimizer_barrier() { std::atomic_thread_fence(std::memory_order_seq_cst); }
+    } // namespace Detail
 
 #endif
 
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
+    template <typename T> inline void deoptimize_value(T &&x) { keep_memory(&x); }
 
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
-            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
-        }
+    template <typename Fn, typename... Args>
+    inline auto invoke_deoptimized(Fn &&fn, Args &&... args) ->
+        typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type
+    {
+      deoptimize_value(std::forward<Fn>(fn)(std::forward<Args...>(args...)));
+    }
 
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
-            std::forward<Fn>(fn) (std::forward<Args...>(args...));
-        }
-    } // namespace Benchmark
+    template <typename Fn, typename... Args>
+    inline auto invoke_deoptimized(Fn &&fn, Args &&... args) ->
+        typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type
+    {
+      std::forward<Fn>(fn)(std::forward<Args...>(args...));
+    }
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_optimizer.hpp
@@ -6318,111 +7095,120 @@ namespace Catch {
 
 // Invoke with a special case for void
 
-
 #include <type_traits>
 #include <utility>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                    return {};
-                }
-            };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
-            }
+  namespace Benchmark {
+    namespace Detail {
+      template <typename T> struct CompleteType
+      {
+        using type = T;
+      };
+      template <> struct CompleteType<void>
+      {
+        struct type
+        {
+        };
+      };
 
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
-        } // namespace Detail
+      template <typename T> using CompleteType_t = typename CompleteType<T>::type;
 
-        template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
-            CATCH_TRY{
-                return Detail::complete_invoke(std::forward<Fun>(fun));
-            } CATCH_CATCH_ALL{
-                getResultCapture().benchmarkFailed(translateActiveException());
-                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
-            }
+      template <typename Result> struct CompleteInvoker
+      {
+        template <typename Fun, typename... Args> static Result invoke(Fun &&fun, Args &&... args)
+        {
+          return std::forward<Fun>(fun)(std::forward<Args>(args)...);
         }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_complete_invoke.hpp
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
+      };
+      template <> struct CompleteInvoker<void>
+      {
+        template <typename Fun, typename... Args>
+        static CompleteType_t<void> invoke(Fun &&fun, Args &&... args)
+        {
+          std::forward<Fun>(fun)(std::forward<Args>(args)...);
+          return {};
+        }
+      };
+      template <typename Sig> using ResultOf_t = typename std::result_of<Sig>::type;
 
-                ClockDuration<Clock> elapsed() const { return finished - started; }
+      // invoke and not return void :(
+      template <typename Fun, typename... Args>
+      CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun &&fun, Args &&... args)
+      {
+        return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun),
+                                                                 std::forward<Args>(args)...);
+      }
 
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
+      const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+    } // namespace Detail
 
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
+    template <typename Fun> Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun &&fun)
+    {
+      CATCH_TRY { return Detail::complete_invoke(std::forward<Fun>(fun)); }
+      CATCH_CATCH_ALL
+      {
+        getResultCapture().benchmarkFailed(translateActiveException());
+        CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+      }
+    }
+  } // namespace Benchmark
+} // namespace Catch
 
-            int runs() const { return k; }
+// end catch_complete_invoke.hpp
+namespace Catch {
+  namespace Benchmark {
+    namespace Detail {
+      struct ChronometerConcept
+      {
+        virtual void start()          = 0;
+        virtual void finish()         = 0;
+        virtual ~ChronometerConcept() = default;
+      };
+      template <typename Clock> struct ChronometerModel final : public ChronometerConcept
+      {
+        void start() override { started = Clock::now(); }
+        void finish() override { finished = Clock::now(); }
+
+        ClockDuration<Clock> elapsed() const { return finished - started; }
+
+        TimePoint<Clock> started;
+        TimePoint<Clock> finished;
+      };
+    } // namespace Detail
 
-            Chronometer(Detail::ChronometerConcept& meter, int k)
-                : impl(&meter)
-                , k(k) {}
+    struct Chronometer
+    {
+    public:
+      template <typename Fun> void measure(Fun &&fun)
+      {
+        measure(std::forward<Fun>(fun), is_callable<Fun(int)>());
+      }
 
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
+      int runs() const { return k; }
 
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
+      Chronometer(Detail::ChronometerConcept &meter, int k) : impl(&meter), k(k) {}
 
-            Detail::ChronometerConcept* impl;
-            int k;
-        };
-    } // namespace Benchmark
+    private:
+      template <typename Fun> void measure(Fun &&fun, std::false_type)
+      {
+        measure([&fun](int) { return fun(); }, std::true_type());
+      }
+
+      template <typename Fun> void measure(Fun &&fun, std::true_type)
+      {
+        Detail::optimizer_barrier();
+        impl->start();
+        for (int i = 0; i < k; ++i)
+          invoke_deoptimized(fun, i);
+        impl->finish();
+        Detail::optimizer_barrier();
+      }
+
+      Detail::ChronometerConcept *impl;
+      int                         k;
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_chronometer.hpp
@@ -6430,124 +7216,122 @@ namespace Catch {
 
 // Environment information
 
-
 namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct EnvironmentEstimate {
-            Duration mean;
-            OutlierClassification outliers;
-
-            template <typename Duration2>
-            operator EnvironmentEstimate<Duration2>() const {
-                return { mean, outliers };
-            }
-        };
-        template <typename Clock>
-        struct Environment {
-            using clock_type = Clock;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
-        };
-    } // namespace Benchmark
+  namespace Benchmark {
+    template <typename Duration> struct EnvironmentEstimate
+    {
+      Duration              mean;
+      OutlierClassification outliers;
+
+      template <typename Duration2> operator EnvironmentEstimate<Duration2>() const
+      {
+        return {mean, outliers};
+      }
+    };
+    template <typename Clock> struct Environment
+    {
+      using clock_type = Clock;
+      EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+      EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_environment.hpp
 // start catch_execution_plan.hpp
 
- // Execution plan
-
+// Execution plan
 
 // start catch_benchmark_function.hpp
 
- // Dumb std::function implementation for consistent call overhead
-
+// Dumb std::function implementation for consistent call overhead
 
 #include <cassert>
+#include <memory>
 #include <type_traits>
 #include <utility>
-#include <memory>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            using Decay = typename std::decay<T>::type;
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<Decay<T>, Decay<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
-
-                    model<Fun>* clone() const override { return new model<Fun>(*this); }
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
-            public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
-
-                template <typename Fun,
-                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
-
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
-
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
-                    return *this;
-                }
+  namespace Benchmark {
+    namespace Detail {
+      template <typename T> using Decay = typename std::decay<T>::type;
+      template <typename T, typename U> struct is_related : std::is_same<Decay<T>, Decay<U>>
+      {
+      };
+
+      /// We need to reinvent std::function because every piece of code that might add overhead
+      /// in a measurement context needs to have consistent performance characteristics so that we
+      /// can account for it in the measurement.
+      /// Implementations of std::function with optimizations that aren't always applicable, like
+      /// small buffer optimizations, are not uncommon.
+      /// This is effectively an implementation of std::function without any such optimizations;
+      /// it may be slow, but it is consistently slow.
+      struct BenchmarkFunction
+      {
+      private:
+        struct callable
+        {
+          virtual void      call(Chronometer meter) const = 0;
+          virtual callable *clone() const                 = 0;
+          virtual ~callable()                             = default;
+        };
+        template <typename Fun> struct model : public callable
+        {
+          model(Fun &&fun) : fun(std::move(fun)) {}
+          model(Fun const &fun) : fun(fun) {}
 
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f.reset(that.f->clone());
-                    return *this;
-                }
+          model<Fun> *clone() const override { return new model<Fun>(*this); }
 
-                void operator()(Chronometer meter) const { f->call(meter); }
+          void call(Chronometer meter) const override
+          {
+            call(meter, is_callable<Fun(Chronometer)>());
+          }
+          void call(Chronometer meter, std::true_type) const { fun(meter); }
+          void call(Chronometer meter, std::false_type) const { meter.measure(fun); }
 
-            private:
-                std::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
+          Fun fun;
+        };
+
+        struct do_nothing
+        {
+          void operator()() const {}
+        };
+
+        template <typename T> BenchmarkFunction(model<T> *c) : f(c) {}
+
+      public:
+        BenchmarkFunction() : f(new model<do_nothing>{{}}) {}
+
+        template <typename Fun, typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value,
+                                                        int>::type = 0>
+        BenchmarkFunction(Fun &&fun)
+            : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun)))
+        {
+        }
+
+        BenchmarkFunction(BenchmarkFunction &&that) : f(std::move(that.f)) {}
+
+        BenchmarkFunction(BenchmarkFunction const &that) : f(that.f->clone()) {}
+
+        BenchmarkFunction &operator=(BenchmarkFunction &&that)
+        {
+          f = std::move(that.f);
+          return *this;
+        }
+
+        BenchmarkFunction &operator=(BenchmarkFunction const &that)
+        {
+          f.reset(that.f->clone());
+          return *this;
+        }
+
+        void operator()(Chronometer meter) const { f->call(meter); }
+
+      private:
+        std::unique_ptr<callable> f;
+      };
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_benchmark_function.hpp
@@ -6555,28 +7339,28 @@ namespace Catch {
 
 // repeat algorithm
 
-
 #include <type_traits>
 #include <utility>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
-                return { std::forward<Fun>(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
+  namespace Benchmark {
+    namespace Detail {
+      template <typename Fun> struct repeater
+      {
+        void operator()(int k) const
+        {
+          for (int i = 0; i < k; ++i) {
+            fun();
+          }
+        }
+        Fun fun;
+      };
+      template <typename Fun> repeater<typename std::decay<Fun>::type> repeat(Fun &&fun)
+      {
+        return {std::forward<Fun>(fun)};
+      }
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_repeat.hpp
@@ -6584,419 +7368,451 @@ namespace Catch {
 
 // Run a function for a minimum amount of time
 
-
 // start catch_measure.hpp
 
 // Measure
 
-
 // start catch_timing.hpp
 
 // Timing
 
-
 #include <tuple>
 #include <type_traits>
 
 namespace Catch {
-    namespace Benchmark {
-        template <typename Duration, typename Result>
-        struct Timing {
-            Duration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
-    } // namespace Benchmark
+  namespace Benchmark {
+    template <typename Duration, typename Result> struct Timing
+    {
+      Duration elapsed;
+      Result   result;
+      int      iterations;
+    };
+    template <typename Clock, typename Sig>
+    using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_timing.hpp
 #include <utility>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, std::forward<decltype(r)>(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
+  namespace Benchmark {
+    namespace Detail {
+      template <typename Clock, typename Fun, typename... Args>
+      TimingOf<Clock, Fun(Args...)> measure(Fun &&fun, Args &&... args)
+      {
+        auto   start = Clock::now();
+        auto &&r     = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+        auto   end   = Clock::now();
+        auto   delta = end - start;
+        return {delta, std::forward<decltype(r)>(r), 1};
+      }
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_measure.hpp
-#include <utility>
 #include <type_traits>
+#include <utility>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), std::move(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
-
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
+  namespace Benchmark {
+    namespace Detail {
+      template <typename Clock, typename Fun>
+      TimingOf<Clock, Fun(int)> measure_one(Fun &&fun, int iters, std::false_type)
+      {
+        return Detail::measure<Clock>(fun, iters);
+      }
+      template <typename Clock, typename Fun>
+      TimingOf<Clock, Fun(Chronometer)> measure_one(Fun &&fun, int iters, std::true_type)
+      {
+        Detail::ChronometerModel<Clock> meter;
+        auto &&result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+        return {meter.elapsed(), std::move(result), iters};
+      }
+
+      template <typename Clock, typename Fun>
+      using run_for_at_least_argument_t =
+          typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
+
+      struct optimized_away_error : std::exception
+      {
+        const char *what() const noexcept override
+        {
+          return "could not measure benchmark, maybe it was optimized away";
+        }
+      };
 
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
-                auto iters = seed;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+      template <typename Clock, typename Fun>
+      TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)>
+      run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun &&fun)
+      {
+        auto iters = seed;
+        while (iters < (1 << 30)) {
+          auto &&Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
 
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, std::move(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw optimized_away_error{};
-            }
-        } // namespace Detail
-    } // namespace Benchmark
+          if (Timing.elapsed >= how_long) {
+            return {Timing.elapsed, std::move(Timing.result), iters};
+          }
+          iters *= 2;
+        }
+        throw optimized_away_error{};
+      }
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_run_for_at_least.hpp
 #include <algorithm>
 
 namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            Duration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            Duration warmup_time;
-            int warmup_iterations;
-
-            template <typename Duration2>
-            operator ExecutionPlan<Duration2>() const {
-                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
-            }
-
-            template <typename Clock>
-            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
-
-                std::vector<FloatDuration<Clock>> times;
-                times.reserve(cfg.benchmarkSamples());
-                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark(Chronometer(model, iterations_per_sample));
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
-                    return sample_time / iterations_per_sample;
-                });
-                return times;
-            }
-        };
-    } // namespace Benchmark
+  namespace Benchmark {
+    template <typename Duration> struct ExecutionPlan
+    {
+      int                       iterations_per_sample;
+      Duration                  estimated_duration;
+      Detail::BenchmarkFunction benchmark;
+      Duration                  warmup_time;
+      int                       warmup_iterations;
+
+      template <typename Duration2> operator ExecutionPlan<Duration2>() const
+      {
+        return {iterations_per_sample, estimated_duration, benchmark, warmup_time,
+                warmup_iterations};
+      }
+
+      template <typename Clock>
+      std::vector<FloatDuration<Clock>> run(const IConfig &                   cfg,
+                                            Environment<FloatDuration<Clock>> env) const
+      {
+        // warmup a bit
+        Detail::run_for_at_least<Clock>(
+            std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations,
+            Detail::repeat(now<Clock>{}));
+
+        std::vector<FloatDuration<Clock>> times;
+        times.reserve(cfg.benchmarkSamples());
+        std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+          Detail::ChronometerModel<Clock> model;
+          this->benchmark(Chronometer(model, iterations_per_sample));
+          auto sample_time = model.elapsed() - env.clock_cost.mean;
+          if (sample_time < FloatDuration<Clock>::zero())
+            sample_time = FloatDuration<Clock>::zero();
+          return sample_time / iterations_per_sample;
+        });
+        return times;
+      }
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_execution_plan.hpp
 // start catch_estimate_clock.hpp
 
- // Environment measurement
-
+// Environment measurement
 
 // start catch_stats.hpp
 
 // Statistical analysis tools
 
-
 #include <algorithm>
+#include <cmath>
+#include <cstddef>
 #include <functional>
-#include <vector>
 #include <numeric>
 #include <tuple>
-#include <cmath>
 #include <utility>
-#include <cstddef>
+#include <vector>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
-
-            template <typename Iterator>
-            OutlierClassification classify_outliers(Iterator first, Iterator last) {
-                std::vector<double> copy(first, last);
-
-                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
-                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
-                auto iqr = q3 - q1;
-                auto los = q1 - (iqr * 3.);
-                auto lom = q1 - (iqr * 1.5);
-                auto him = q3 + (iqr * 1.5);
-                auto his = q3 + (iqr * 3.);
-
-                OutlierClassification o;
-                for (; first != last; ++first) {
-                    auto&& t = *first;
-                    if (t < los) ++o.low_severe;
-                    else if (t < lom) ++o.low_mild;
-                    else if (t > his) ++o.high_severe;
-                    else if (t > him) ++o.high_mild;
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            template <typename Iterator>
-            double mean(Iterator first, Iterator last) {
-                auto count = last - first;
-                double sum = std::accumulate(first, last, 0.);
-                return sum / count;
-            }
-
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                sample out;
-                out.reserve(resamples);
-                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
-                    std::vector<double> resampled;
-                    resampled.reserve(n);
-                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
-            template <typename Estimator, typename Iterator>
-            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
-                auto n = last - first;
-                auto second = std::next(first);
-                sample results;
-                results.reserve(n);
-
-                for (auto it = first; it != last; ++it) {
-                    std::iter_swap(it, first);
-                    results.push_back(estimator(second, last));
-                }
-
-                return results;
-            }
-
-            inline double normal_cdf(double x) {
-                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
-            }
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            template <typename Iterator, typename Estimator>
-            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
-                auto n_samples = last - first;
-
-                double point = estimator(first, last);
-                // Degenerate case with a single sample
-                if (n_samples == 1) return { point, point, point, confidence_level };
-
-                sample jack = jackknife(estimator, first, last);
-                double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares, sum_cubes;
-                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
-                    auto d = jack_mean - x;
-                    auto d2 = d * d;
-                    auto d3 = d2 * d;
-                    return { sqcb.first + d2, sqcb.second + d3 };
-                });
-
-                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
-                int n = static_cast<int>(resample.size());
-                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
-                // degenerate case with uniform samples
-                if (prob_n == 0) return { point, point, point, confidence_level };
-
-                double bias = normal_quantile(prob_n);
-                double z1 = normal_quantile((1. - confidence_level) / 2.);
-
-                auto cumn = [n](double x) -> int {
-                    return std::lround(normal_cdf(x) * n); };
-                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a(b1);
-                double a2 = a(b2);
-                auto lo = std::max(cumn(a1), 0);
-                auto hi = std::min(cumn(a2), n - 1);
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
-        } // namespace Detail
-    } // namespace Benchmark
+  namespace Benchmark {
+    namespace Detail {
+      using sample = std::vector<double>;
+
+      double weighted_average_quantile(int k, int q, std::vector<double>::iterator first,
+                                       std::vector<double>::iterator last);
+
+      template <typename Iterator>
+      OutlierClassification classify_outliers(Iterator first, Iterator last)
+      {
+        std::vector<double> copy(first, last);
+
+        auto q1  = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+        auto q3  = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+        auto iqr = q3 - q1;
+        auto los = q1 - (iqr * 3.);
+        auto lom = q1 - (iqr * 1.5);
+        auto him = q3 + (iqr * 1.5);
+        auto his = q3 + (iqr * 3.);
+
+        OutlierClassification o;
+        for (; first != last; ++first) {
+          auto &&t = *first;
+          if (t < los)
+            ++o.low_severe;
+          else if (t < lom)
+            ++o.low_mild;
+          else if (t > his)
+            ++o.high_severe;
+          else if (t > him)
+            ++o.high_mild;
+          ++o.samples_seen;
+        }
+        return o;
+      }
+
+      template <typename Iterator> double mean(Iterator first, Iterator last)
+      {
+        auto   count = last - first;
+        double sum   = std::accumulate(first, last, 0.);
+        return sum / count;
+      }
+
+      template <typename URng, typename Iterator, typename Estimator>
+      sample resample(URng &rng, int resamples, Iterator first, Iterator last, Estimator &estimator)
+      {
+        auto                                       n = last - first;
+        std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+        sample out;
+        out.reserve(resamples);
+        std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+          std::vector<double> resampled;
+          resampled.reserve(n);
+          std::generate_n(std::back_inserter(resampled), n,
+                          [first, &dist, &rng] { return first[dist(rng)]; });
+          return estimator(resampled.begin(), resampled.end());
+        });
+        std::sort(out.begin(), out.end());
+        return out;
+      }
+
+      template <typename Estimator, typename Iterator>
+      sample jackknife(Estimator &&estimator, Iterator first, Iterator last)
+      {
+        auto   n      = last - first;
+        auto   second = std::next(first);
+        sample results;
+        results.reserve(n);
+
+        for (auto it = first; it != last; ++it) {
+          std::iter_swap(it, first);
+          results.push_back(estimator(second, last));
+        }
+
+        return results;
+      }
+
+      inline double normal_cdf(double x) { return std::erfc(-x / std::sqrt(2.0)) / 2.0; }
+
+      double erfc_inv(double x);
+
+      double normal_quantile(double p);
+
+      template <typename Iterator, typename Estimator>
+      Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last,
+                                 sample const &resample, Estimator &&estimator)
+      {
+        auto n_samples = last - first;
+
+        double point = estimator(first, last);
+        // Degenerate case with a single sample
+        if (n_samples == 1)
+          return {point, point, point, confidence_level};
+
+        sample jack      = jackknife(estimator, first, last);
+        double jack_mean = mean(jack.begin(), jack.end());
+        double sum_squares, sum_cubes;
+        std::tie(sum_squares, sum_cubes) = std::accumulate(
+            jack.begin(), jack.end(), std::make_pair(0., 0.),
+            [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+              auto d  = jack_mean - x;
+              auto d2 = d * d;
+              auto d3 = d2 * d;
+              return {sqcb.first + d2, sqcb.second + d3};
+            });
+
+        double accel  = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+        int    n      = static_cast<int>(resample.size());
+        double prob_n = std::count_if(resample.begin(), resample.end(),
+                                      [point](double x) { return x < point; }) /
+                        (double)n;
+        // degenerate case with uniform samples
+        if (prob_n == 0)
+          return {point, point, point, confidence_level};
+
+        double bias = normal_quantile(prob_n);
+        double z1   = normal_quantile((1. - confidence_level) / 2.);
+
+        auto   cumn = [n](double x) -> int { return std::lround(normal_cdf(x) * n); };
+        auto   a    = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+        double b1   = bias + z1;
+        double b2   = bias - z1;
+        double a1   = a(b1);
+        double a2   = a(b2);
+        auto   lo   = std::max(cumn(a1), 0);
+        auto   hi   = std::min(cumn(a2), n - 1);
+
+        return {point, resample[lo], resample[hi], confidence_level};
+      }
+
+      double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+      struct bootstrap_analysis
+      {
+        Estimate<double> mean;
+        Estimate<double> standard_deviation;
+        double           outlier_variance;
+      };
+
+      bootstrap_analysis analyse_samples(double confidence_level, int n_resamples,
+                                         std::vector<double>::iterator first,
+                                         std::vector<double>::iterator last);
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_stats.hpp
 #include <algorithm>
+#include <cmath>
 #include <iterator>
 #include <tuple>
 #include <vector>
-#include <cmath>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(k + 1);
-                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
-
-                std::vector<double> deltas;
-                deltas.reserve(k);
-                std::transform(std::next(times.begin()), times.end(), times.begin(),
-                    std::back_inserter(deltas),
-                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
-
-                return deltas;
-            }
-
-            const auto warmup_iterations = 10000;
-            const auto warmup_time = std::chrono::milliseconds(100);
-            const auto minimum_ticks = 1000;
-            const auto warmup_seed = 10000;
-            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            const auto clock_cost_estimation_tick_limit = 100000;
-            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            const auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FloatDuration<Clock>(mean(r.begin(), r.end())),
-                    classify_outliers(r.begin(), r.end()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(nsamples);
-                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
-                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
-                });
-                return {
-                    FloatDuration<Clock>(mean(times.begin(), times.end())),
-                    classify_outliers(times.begin(), times.end()),
-                };
-            }
+  namespace Benchmark {
+    namespace Detail {
+      template <typename Clock> std::vector<double> resolution(int k)
+      {
+        std::vector<TimePoint<Clock>> times;
+        times.reserve(k + 1);
+        std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+        std::vector<double> deltas;
+        deltas.reserve(k);
+        std::transform(std::next(times.begin()), times.end(), times.begin(),
+                       std::back_inserter(deltas), [](TimePoint<Clock> a, TimePoint<Clock> b) {
+                         return static_cast<double>((a - b).count());
+                       });
+
+        return deltas;
+      }
+
+      const auto warmup_iterations                = 10000;
+      const auto warmup_time                      = std::chrono::milliseconds(100);
+      const auto minimum_ticks                    = 1000;
+      const auto warmup_seed                      = 10000;
+      const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+      const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+      const auto clock_cost_estimation_tick_limit = 100000;
+      const auto clock_cost_estimation_time       = std::chrono::milliseconds(10);
+      const auto clock_cost_estimation_iterations = 10000;
+
+      template <typename Clock> int warmup()
+      {
+        return run_for_at_least<Clock>(
+                   std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed,
+                   &resolution<Clock>)
+            .iterations;
+      }
+      template <typename Clock>
+      EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations)
+      {
+        auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(
+                                             clock_resolution_estimation_time),
+                                         iterations, &resolution<Clock>)
+                     .result;
+        return {
+            FloatDuration<Clock>(mean(r.begin(), r.end())),
+            classify_outliers(r.begin(), r.end()),
+        };
+      }
+      template <typename Clock>
+      EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution)
+      {
+        auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit,
+                                   FloatDuration<Clock>(clock_cost_estimation_time_limit));
+        auto time_clock = [](int k) {
+          return Detail::measure<Clock>([k] {
+                   for (int i = 0; i < k; ++i) {
+                     volatile auto ignored = Clock::now();
+                     (void)ignored;
+                   }
+                 })
+              .elapsed;
+        };
+        time_clock(1);
+        int    iters = clock_cost_estimation_iterations;
+        auto &&r     = run_for_at_least<Clock>(
+            std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters,
+            time_clock);
+        std::vector<double> times;
+        int                 nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+        times.reserve(nsamples);
+        std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+          return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+        });
+        return {
+            FloatDuration<Clock>(mean(times.begin(), times.end())),
+            classify_outliers(times.begin(), times.end()),
+        };
+      }
 
-            template <typename Clock>
-            Environment<FloatDuration<Clock>> measure_environment() {
-                static Environment<FloatDuration<Clock>>* env = nullptr;
-                if (env) {
-                    return *env;
-                }
+      template <typename Clock> Environment<FloatDuration<Clock>> measure_environment()
+      {
+        static Environment<FloatDuration<Clock>> *env = nullptr;
+        if (env) {
+          return *env;
+        }
 
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+        auto iters      = Detail::warmup<Clock>();
+        auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+        auto cost       = Detail::estimate_clock_cost<Clock>(resolution.mean);
 
-                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
+        env = new Environment<FloatDuration<Clock>>{resolution, cost};
+        return *env;
+      }
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_estimate_clock.hpp
 // start catch_analyse.hpp
 
- // Run and analyse one benchmark
-
+// Run and analyse one benchmark
 
 // start catch_sample_analysis.hpp
 
 // Benchmark results
 
-
 #include <algorithm>
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct SampleAnalysis {
-            std::vector<Duration> samples;
-            Estimate<Duration> mean;
-            Estimate<Duration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-
-            template <typename Duration2>
-            operator SampleAnalysis<Duration2>() const {
-                std::vector<Duration2> samples2;
-                samples2.reserve(samples.size());
-                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-                return {
-                    std::move(samples2),
-                    mean,
-                    standard_deviation,
-                    outliers,
-                    outlier_variance,
-                };
-            }
+  namespace Benchmark {
+    template <typename Duration> struct SampleAnalysis
+    {
+      std::vector<Duration> samples;
+      Estimate<Duration>    mean;
+      Estimate<Duration>    standard_deviation;
+      OutlierClassification outliers;
+      double                outlier_variance;
+
+      template <typename Duration2> operator SampleAnalysis<Duration2>() const
+      {
+        std::vector<Duration2> samples2;
+        samples2.reserve(samples.size());
+        std::transform(samples.begin(), samples.end(), std::back_inserter(samples2),
+                       [](Duration d) { return Duration2(d); });
+        return {
+            std::move(samples2), mean, standard_deviation, outliers, outlier_variance,
         };
-    } // namespace Benchmark
+      }
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 // end catch_sample_analysis.hpp
@@ -7005,155 +7821,168 @@ namespace Catch {
 #include <vector>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Duration, typename Iterator>
-            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(last - first);
-                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<Duration> {
-                            Duration(e.point),
-                                Duration(e.lower_bound),
-                                Duration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<Duration> samples2;
-                    samples2.reserve(samples.size());
-                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
-                    return {
-                        std::move(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<Duration> samples;
-                    samples.reserve(last - first);
-
-                    Duration mean = Duration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(Duration(*it));
-                        mean += Duration(*it);
-                    }
-                    mean /= i;
-
-                    return {
-                        std::move(samples),
-                        Estimate<Duration>{mean, mean, mean, 0.0},
-                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
+  namespace Benchmark {
+    namespace Detail {
+      template <typename Duration, typename Iterator>
+      SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first,
+                                       Iterator last)
+      {
+        if (!cfg.benchmarkNoAnalysis()) {
+          std::vector<double> samples;
+          samples.reserve(last - first);
+          std::transform(first, last, std::back_inserter(samples),
+                         [](Duration d) { return d.count(); });
+
+          auto analysis = Catch::Benchmark::Detail::analyse_samples(
+              cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(),
+              samples.end());
+          auto outliers =
+              Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+          auto wrap_estimate = [](Estimate<double> e) {
+            return Estimate<Duration>{
+                Duration(e.point),
+                Duration(e.lower_bound),
+                Duration(e.upper_bound),
+                e.confidence_interval,
+            };
+          };
+          std::vector<Duration> samples2;
+          samples2.reserve(samples.size());
+          std::transform(samples.begin(), samples.end(), std::back_inserter(samples2),
+                         [](double d) { return Duration(d); });
+          return {
+              std::move(samples2),
+              wrap_estimate(analysis.mean),
+              wrap_estimate(analysis.standard_deviation),
+              outliers,
+              analysis.outlier_variance,
+          };
+        }
+        else {
+          std::vector<Duration> samples;
+          samples.reserve(last - first);
+
+          Duration mean = Duration(0);
+          int      i    = 0;
+          for (auto it = first; it < last; ++it, ++i) {
+            samples.push_back(Duration(*it));
+            mean += Duration(*it);
+          }
+          mean /= i;
+
+          return {std::move(samples), Estimate<Duration>{mean, mean, mean, 0.0},
+                  Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                  OutlierClassification{}, 0.0};
+        }
+      }
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 // end catch_analyse.hpp
 #include <algorithm>
+#include <cmath>
 #include <functional>
 #include <string>
 #include <vector>
-#include <cmath>
 
 namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
-
-            template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
-
-            template <typename Clock>
-            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(Detail::warmup_time));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        name,
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<std::chrono::duration<double, std::nano>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-
-                } CATCH_CATCH_ALL{
-                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
-                        std::rethrow_exception(std::current_exception());
-                }
-            }
+  namespace Benchmark {
+    struct Benchmark
+    {
+      Benchmark(std::string &&name) : name(std::move(name)) {}
+
+      template <class FUN>
+      Benchmark(std::string &&name, FUN &&func) : fun(std::move(func)), name(std::move(name))
+      {
+      }
+
+      template <typename Clock>
+      ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &                   cfg,
+                                                  Environment<FloatDuration<Clock>> env) const
+      {
+        auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+        auto run_time =
+            std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(Detail::warmup_time));
+        auto &&test = Detail::run_for_at_least<Clock>(
+            std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+        int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+        return {new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun,
+                std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time),
+                Detail::warmup_iterations};
+      }
+
+      template <typename Clock = default_clock> void run()
+      {
+        IConfigPtr cfg = getCurrentContext().getConfig();
+
+        auto env = Detail::measure_environment<Clock>();
+
+        getResultCapture().benchmarkPreparing(name);
+        CATCH_TRY
+        {
+          auto plan = user_code([&] { return prepare<Clock>(*cfg, env); });
+
+          BenchmarkInfo info{name,
+                             plan.estimated_duration.count(),
+                             plan.iterations_per_sample,
+                             cfg->benchmarkSamples(),
+                             cfg->benchmarkResamples(),
+                             env.clock_resolution.mean.count(),
+                             env.clock_cost.mean.count()};
+
+          getResultCapture().benchmarkStarting(info);
+
+          auto samples = user_code([&] { return plan.template run<Clock>(*cfg, env); });
+
+          auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+          BenchmarkStats<std::chrono::duration<double, std::nano>> stats{
+              info,
+              analysis.samples,
+              analysis.mean,
+              analysis.standard_deviation,
+              analysis.outliers,
+              analysis.outlier_variance};
+          getResultCapture().benchmarkEnded(stats);
+        }
+        CATCH_CATCH_ALL
+        {
+          if (translateActiveException() !=
+              Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+            std::rethrow_exception(std::current_exception());
+        }
+      }
 
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun,
+      // sets lambda to be used in fun *and* executes benchmark!
+      template <typename Fun,
                 typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
-                Benchmark & operator=(Fun func) {
-                fun = Detail::BenchmarkFunction(func);
-                run();
-                return *this;
-            }
+      Benchmark &operator=(Fun func)
+      {
+        fun = Detail::BenchmarkFunction(func);
+        run();
+        return *this;
+      }
 
-            explicit operator bool() {
-                return true;
-            }
+      explicit operator bool() { return true; }
 
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
+    private:
+      Detail::BenchmarkFunction fun;
+      std::string               name;
+    };
+  } // namespace Benchmark
 } // namespace Catch
 
 #define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
 #define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
 
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)                              \
+  if (Catch::Benchmark::Benchmark BenchmarkName{name})                                             \
+  BenchmarkName = [&](int benchmarkIndex)
 
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)                                     \
+  if (Catch::Benchmark::Benchmark BenchmarkName{name})                                             \
+  BenchmarkName = [&]
 
 // end catch_benchmark.hpp
 #endif
@@ -7171,147 +8000,149 @@ namespace Catch {
 // Keep these here for external reporters
 // start catch_test_case_tracker.h
 
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
 
 namespace Catch {
-namespace TestCaseTracking {
+  namespace TestCaseTracking {
 
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
+    struct NameAndLocation
+    {
+      std::string    name;
+      SourceLineInfo location;
 
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+      NameAndLocation(std::string const &_name, SourceLineInfo const &_location);
     };
 
     struct ITracker;
 
     using ITrackerPtr = std::shared_ptr<ITracker>;
 
-    struct ITracker {
-        virtual ~ITracker();
+    struct ITracker
+    {
+      virtual ~ITracker();
 
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
+      // static queries
+      virtual NameAndLocation const &nameAndLocation() const = 0;
 
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
+      // dynamic queries
+      virtual bool isComplete() const              = 0; // Successfully completed or failed
+      virtual bool isSuccessfullyCompleted() const = 0;
+      virtual bool isOpen() const                  = 0; // Started but not complete
+      virtual bool hasChildren() const             = 0;
 
-        virtual ITracker& parent() = 0;
+      virtual ITracker &parent() = 0;
 
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
+      // actions
+      virtual void close()                   = 0; // Successfully complete
+      virtual void fail()                    = 0;
+      virtual void markAsNeedingAnotherRun() = 0;
 
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
+      virtual void        addChild(ITrackerPtr const &child)                = 0;
+      virtual ITrackerPtr findChild(NameAndLocation const &nameAndLocation) = 0;
+      virtual void        openChild()                                       = 0;
 
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isGeneratorTracker() const = 0;
+      // Debug/ checking
+      virtual bool isSectionTracker() const   = 0;
+      virtual bool isGeneratorTracker() const = 0;
     };
 
-    class TrackerContext {
+    class TrackerContext
+    {
 
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
+      enum RunState { NotStarted, Executing, CompletedCycle };
 
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
+      ITrackerPtr m_rootTracker;
+      ITracker *  m_currentTracker = nullptr;
+      RunState    m_runState       = NotStarted;
 
     public:
+      ITracker &startRun();
+      void      endRun();
 
-        ITracker& startRun();
-        void endRun();
+      void startCycle();
+      void completeCycle();
 
-        void startCycle();
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
+      bool      completedCycle() const;
+      ITracker &currentTracker();
+      void      setCurrentTracker(ITracker *tracker);
     };
 
-    class TrackerBase : public ITracker {
+    class TrackerBase : public ITracker
+    {
     protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
+      enum CycleState {
+        NotStarted,
+        Executing,
+        ExecutingChildren,
+        NeedsAnotherRun,
+        CompletedSuccessfully,
+        Failed
+      };
+
+      using Children = std::vector<ITrackerPtr>;
+      NameAndLocation m_nameAndLocation;
+      TrackerContext &m_ctx;
+      ITracker *      m_parent;
+      Children        m_children;
+      CycleState      m_runState = NotStarted;
 
     public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+      TrackerBase(NameAndLocation const &nameAndLocation, TrackerContext &ctx, ITracker *parent);
 
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
+      NameAndLocation const &nameAndLocation() const override;
+      bool                   isComplete() const override;
+      bool                   isSuccessfullyCompleted() const override;
+      bool                   isOpen() const override;
+      bool                   hasChildren() const override;
 
-        void addChild( ITrackerPtr const& child ) override;
+      void addChild(ITrackerPtr const &child) override;
 
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
+      ITrackerPtr findChild(NameAndLocation const &nameAndLocation) override;
+      ITracker &  parent() override;
 
-        void openChild() override;
+      void openChild() override;
 
-        bool isSectionTracker() const override;
-        bool isGeneratorTracker() const override;
+      bool isSectionTracker() const override;
+      bool isGeneratorTracker() const override;
 
-        void open();
+      void open();
 
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
+      void close() override;
+      void fail() override;
+      void markAsNeedingAnotherRun() override;
 
     private:
-        void moveToParent();
-        void moveToThis();
+      void moveToParent();
+      void moveToThis();
     };
 
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
+    class SectionTracker : public TrackerBase
+    {
+      std::vector<std::string> m_filters;
+      std::string              m_trimmed_name;
+
     public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+      SectionTracker(NameAndLocation const &nameAndLocation, TrackerContext &ctx, ITracker *parent);
 
-        bool isSectionTracker() const override;
+      bool isSectionTracker() const override;
 
-        bool isComplete() const override;
+      bool isComplete() const override;
 
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+      static SectionTracker &acquire(TrackerContext &ctx, NameAndLocation const &nameAndLocation);
 
-        void tryOpen();
+      void tryOpen();
 
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
+      void addInitialFilters(std::vector<std::string> const &filters);
+      void addNextFilters(std::vector<std::string> const &filters);
     };
 
-} // namespace TestCaseTracking
+  } // namespace TestCaseTracking
 
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
+  using TestCaseTracking::ITracker;
+  using TestCaseTracking::SectionTracker;
+  using TestCaseTracking::TrackerContext;
 
 } // namespace Catch
 
@@ -7321,12 +8152,13 @@ using TestCaseTracking::SectionTracker;
 
 namespace Catch {
 
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
+  struct LeakDetector
+  {
+    LeakDetector();
+    ~LeakDetector();
+  };
 
-}
+} // namespace Catch
 // end catch_leak_detector.h
 // Cpp files will be included in the single-header file here
 // start catch_stats.cpp
@@ -7343,198 +8175,214 @@ namespace Catch {
 #endif
 
 namespace {
-    double erf_inv(double x) {
-        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
-        double w, p;
-
-        w = -log((1.0 - x) * (1.0 + x));
-
-        if (w < 6.250000) {
-            w = w - 3.125000;
-            p = -3.6444120640178196996e-21;
-            p = -1.685059138182016589e-19 + p * w;
-            p = 1.2858480715256400167e-18 + p * w;
-            p = 1.115787767802518096e-17 + p * w;
-            p = -1.333171662854620906e-16 + p * w;
-            p = 2.0972767875968561637e-17 + p * w;
-            p = 6.6376381343583238325e-15 + p * w;
-            p = -4.0545662729752068639e-14 + p * w;
-            p = -8.1519341976054721522e-14 + p * w;
-            p = 2.6335093153082322977e-12 + p * w;
-            p = -1.2975133253453532498e-11 + p * w;
-            p = -5.4154120542946279317e-11 + p * w;
-            p = 1.051212273321532285e-09 + p * w;
-            p = -4.1126339803469836976e-09 + p * w;
-            p = -2.9070369957882005086e-08 + p * w;
-            p = 4.2347877827932403518e-07 + p * w;
-            p = -1.3654692000834678645e-06 + p * w;
-            p = -1.3882523362786468719e-05 + p * w;
-            p = 0.0001867342080340571352 + p * w;
-            p = -0.00074070253416626697512 + p * w;
-            p = -0.0060336708714301490533 + p * w;
-            p = 0.24015818242558961693 + p * w;
-            p = 1.6536545626831027356 + p * w;
-        } else if (w < 16.000000) {
-            w = sqrt(w) - 3.250000;
-            p = 2.2137376921775787049e-09;
-            p = 9.0756561938885390979e-08 + p * w;
-            p = -2.7517406297064545428e-07 + p * w;
-            p = 1.8239629214389227755e-08 + p * w;
-            p = 1.5027403968909827627e-06 + p * w;
-            p = -4.013867526981545969e-06 + p * w;
-            p = 2.9234449089955446044e-06 + p * w;
-            p = 1.2475304481671778723e-05 + p * w;
-            p = -4.7318229009055733981e-05 + p * w;
-            p = 6.8284851459573175448e-05 + p * w;
-            p = 2.4031110387097893999e-05 + p * w;
-            p = -0.0003550375203628474796 + p * w;
-            p = 0.00095328937973738049703 + p * w;
-            p = -0.0016882755560235047313 + p * w;
-            p = 0.0024914420961078508066 + p * w;
-            p = -0.0037512085075692412107 + p * w;
-            p = 0.005370914553590063617 + p * w;
-            p = 1.0052589676941592334 + p * w;
-            p = 3.0838856104922207635 + p * w;
-        } else {
-            w = sqrt(w) - 5.000000;
-            p = -2.7109920616438573243e-11;
-            p = -2.5556418169965252055e-10 + p * w;
-            p = 1.5076572693500548083e-09 + p * w;
-            p = -3.7894654401267369937e-09 + p * w;
-            p = 7.6157012080783393804e-09 + p * w;
-            p = -1.4960026627149240478e-08 + p * w;
-            p = 2.9147953450901080826e-08 + p * w;
-            p = -6.7711997758452339498e-08 + p * w;
-            p = 2.2900482228026654717e-07 + p * w;
-            p = -9.9298272942317002539e-07 + p * w;
-            p = 4.5260625972231537039e-06 + p * w;
-            p = -1.9681778105531670567e-05 + p * w;
-            p = 7.5995277030017761139e-05 + p * w;
-            p = -0.00021503011930044477347 + p * w;
-            p = -0.00013871931833623122026 + p * w;
-            p = 1.0103004648645343977 + p * w;
-            p = 4.8499064014085844221 + p * w;
-        }
-        return p * x;
-    }
-
-    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
-        auto m = Catch::Benchmark::Detail::mean(first, last);
-        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
-            double diff = b - m;
-            return a + diff * diff;
-            }) / (last - first);
-            return std::sqrt(variance);
-    }
-
-}
+  double erf_inv(double x)
+  {
+    // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems,
+    // Volume 2
+    double w, p;
+
+    w = -log((1.0 - x) * (1.0 + x));
+
+    if (w < 6.250000) {
+      w = w - 3.125000;
+      p = -3.6444120640178196996e-21;
+      p = -1.685059138182016589e-19 + p * w;
+      p = 1.2858480715256400167e-18 + p * w;
+      p = 1.115787767802518096e-17 + p * w;
+      p = -1.333171662854620906e-16 + p * w;
+      p = 2.0972767875968561637e-17 + p * w;
+      p = 6.6376381343583238325e-15 + p * w;
+      p = -4.0545662729752068639e-14 + p * w;
+      p = -8.1519341976054721522e-14 + p * w;
+      p = 2.6335093153082322977e-12 + p * w;
+      p = -1.2975133253453532498e-11 + p * w;
+      p = -5.4154120542946279317e-11 + p * w;
+      p = 1.051212273321532285e-09 + p * w;
+      p = -4.1126339803469836976e-09 + p * w;
+      p = -2.9070369957882005086e-08 + p * w;
+      p = 4.2347877827932403518e-07 + p * w;
+      p = -1.3654692000834678645e-06 + p * w;
+      p = -1.3882523362786468719e-05 + p * w;
+      p = 0.0001867342080340571352 + p * w;
+      p = -0.00074070253416626697512 + p * w;
+      p = -0.0060336708714301490533 + p * w;
+      p = 0.24015818242558961693 + p * w;
+      p = 1.6536545626831027356 + p * w;
+    }
+    else if (w < 16.000000) {
+      w = sqrt(w) - 3.250000;
+      p = 2.2137376921775787049e-09;
+      p = 9.0756561938885390979e-08 + p * w;
+      p = -2.7517406297064545428e-07 + p * w;
+      p = 1.8239629214389227755e-08 + p * w;
+      p = 1.5027403968909827627e-06 + p * w;
+      p = -4.013867526981545969e-06 + p * w;
+      p = 2.9234449089955446044e-06 + p * w;
+      p = 1.2475304481671778723e-05 + p * w;
+      p = -4.7318229009055733981e-05 + p * w;
+      p = 6.8284851459573175448e-05 + p * w;
+      p = 2.4031110387097893999e-05 + p * w;
+      p = -0.0003550375203628474796 + p * w;
+      p = 0.00095328937973738049703 + p * w;
+      p = -0.0016882755560235047313 + p * w;
+      p = 0.0024914420961078508066 + p * w;
+      p = -0.0037512085075692412107 + p * w;
+      p = 0.005370914553590063617 + p * w;
+      p = 1.0052589676941592334 + p * w;
+      p = 3.0838856104922207635 + p * w;
+    }
+    else {
+      w = sqrt(w) - 5.000000;
+      p = -2.7109920616438573243e-11;
+      p = -2.5556418169965252055e-10 + p * w;
+      p = 1.5076572693500548083e-09 + p * w;
+      p = -3.7894654401267369937e-09 + p * w;
+      p = 7.6157012080783393804e-09 + p * w;
+      p = -1.4960026627149240478e-08 + p * w;
+      p = 2.9147953450901080826e-08 + p * w;
+      p = -6.7711997758452339498e-08 + p * w;
+      p = 2.2900482228026654717e-07 + p * w;
+      p = -9.9298272942317002539e-07 + p * w;
+      p = 4.5260625972231537039e-06 + p * w;
+      p = -1.9681778105531670567e-05 + p * w;
+      p = 7.5995277030017761139e-05 + p * w;
+      p = -0.00021503011930044477347 + p * w;
+      p = -0.00013871931833623122026 + p * w;
+      p = 1.0103004648645343977 + p * w;
+      p = 4.8499064014085844221 + p * w;
+    }
+    return p * x;
+  }
 
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if (g == 0) return xj;
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
+  double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last)
+  {
+    auto   m        = Catch::Benchmark::Detail::mean(first, last);
+    double variance = std::accumulate(first, last, 0.,
+                                      [m](double a, double b) {
+                                        double diff = b - m;
+                                        return a + diff * diff;
+                                      }) /
+                      (last - first);
+    return std::sqrt(variance);
+  }
 
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
+} // namespace
 
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
+namespace Catch {
+  namespace Benchmark {
+    namespace Detail {
 
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
+      double weighted_average_quantile(int k, int q, std::vector<double>::iterator first,
+                                       std::vector<double>::iterator last)
+      {
+        auto   count = last - first;
+        double idx   = (count - 1) * k / static_cast<double>(q);
+        int    j     = static_cast<int>(idx);
+        double g     = idx - j;
+        std::nth_element(first, first + j, last);
+        auto xj = first[j];
+        if (g == 0)
+          return xj;
+
+        auto xj1 = *std::min_element(first + (j + 1), last);
+        return xj + g * (xj1 - xj);
+      }
+
+      double erfc_inv(double x) { return erf_inv(1.0 - x); }
+
+      double normal_quantile(double p)
+      {
+        static const double ROOT_TWO = std::sqrt(2.0);
+
+        double result = 0.0;
+        assert(p >= 0 && p <= 1);
+        if (p < 0 || p > 1) {
+          return result;
+        }
+
+        result = -erfc_inv(2.0 * p);
+        // result *= normal distribution standard deviation (1.0) * sqrt(2)
+        result *= /*sd * */ ROOT_TWO;
+        // result += normal disttribution mean (0)
+        return result;
+      }
+
+      double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n)
+      {
+        double sb     = stddev.point;
+        double mn     = mean.point / n;
+        double mg_min = mn / 2.;
+        double sg     = std::min(mg_min / 4., sb / std::sqrt(n));
+        double sg2    = sg * sg;
+        double sb2    = sb * sb;
+
+        auto c_max = [n, mn, sb2, sg2](double x) -> double {
+          double k   = mn - x;
+          double d   = k * k;
+          double nd  = n * d;
+          double k0  = -n * nd;
+          double k1  = sb2 - n * sg2 + nd;
+          double det = k1 * k1 - 4 * sg2 * k0;
+          return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+        };
 
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
+        auto var_out = [n, sb2, sg2](double c) {
+          double nc = n - c;
+          return (nc / n) * (sb2 - nc * sg2);
+        };
 
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
-                double sb = stddev.point;
-                double mn = mean.point / n;
-                double mg_min = mn / 2.;
-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
-                double sg2 = sg * sg;
-                double sb2 = sb * sb;
-
-                auto c_max = [n, mn, sb2, sg2](double x) -> double {
-                    double k = mn - x;
-                    double d = k * k;
-                    double nd = n * d;
-                    double k0 = -n * nd;
-                    double k1 = sb2 - n * sg2 + nd;
-                    double det = k1 * k1 - 4 * sg2 * k0;
-                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
-                };
-
-                auto var_out = [n, sb2, sg2](double c) {
-                    double nc = n - c;
-                    return (nc / n) * (sb2 - nc * sg2);
-                };
-
-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
-            }
+        return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+      }
 
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-                static std::random_device entropy;
-                CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+      bootstrap_analysis analyse_samples(double confidence_level, int n_resamples,
+                                         std::vector<double>::iterator first,
+                                         std::vector<double>::iterator last)
+      {
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+        static std::random_device entropy;
+        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+        auto n = static_cast<int>(
+            last - first); // seriously, one can't use integral types without hell in C++
 
-                auto mean = &Detail::mean<std::vector<double>::iterator>;
-                auto stddev = &standard_deviation;
+        auto mean   = &Detail::mean<std::vector<double>::iterator>;
+        auto stddev = &standard_deviation;
 
 #if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    return std::async(std::launch::async, [=] {
-                        std::mt19937 rng(seed);
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
+        auto Estimate =
+            [=](double (*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+              auto seed = entropy();
+              return std::async(std::launch::async, [=] {
+                std::mt19937 rng(seed);
+                auto         resampled = resample(rng, n_resamples, first, last, f);
+                return bootstrap(confidence_level, first, last, resampled, f);
+              });
+            };
+
+        auto mean_future   = Estimate(mean);
+        auto stddev_future = Estimate(stddev);
+
+        auto mean_estimate   = mean_future.get();
+        auto stddev_estimate = stddev_future.get();
 #else
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    std::mt19937 rng(seed);
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
+        auto Estimate =
+            [=](double (*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+              auto         seed = entropy();
+              std::mt19937 rng(seed);
+              auto         resampled = resample(rng, n_resamples, first, last, f);
+              return bootstrap(confidence_level, first, last, resampled, f);
+            };
+
+        auto mean_estimate   = Estimate(mean);
+        auto stddev_estimate = Estimate(stddev);
 #endif // CATCH_USE_ASYNC
 
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+        double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
 
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
+        return {mean_estimate, stddev_estimate, outlier_variance};
+      }
+    } // namespace Detail
+  }   // namespace Benchmark
 } // namespace Catch
 
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
@@ -7546,74 +8394,76 @@ namespace Catch {
 
 namespace {
 
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
+  // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+  // But without the subtraction to allow for INFINITY in comparison
+  bool marginComparison(double lhs, double rhs, double margin)
+  {
     return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
+  }
 
-}
+} // namespace
 
 namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
+  namespace Detail {
 
-    Approx Approx::custom() {
-        return Approx( 0 );
+    Approx::Approx(double value)
+        : m_epsilon(std::numeric_limits<float>::epsilon() * 100), m_margin(0.0), m_scale(0.0),
+          m_value(value)
+    {
     }
 
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
+    Approx Approx::custom() { return Approx(0); }
+
+    Approx Approx::operator-() const
+    {
+      auto temp(*this);
+      temp.m_value = -temp.m_value;
+      return temp;
     }
 
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
+    std::string Approx::toString() const
+    {
+      ReusableStringStream rss;
+      rss << "Approx( " << ::Catch::Detail::stringify(m_value) << " )";
+      return rss.str();
     }
 
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
+    bool Approx::equalityComparisonImpl(const double other) const
+    {
+      // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+      // Thanks to Richard Harris for his help refining the scaled margin value
+      return marginComparison(m_value, other, m_margin) ||
+             marginComparison(m_value, other,
+                              m_epsilon * (m_scale + std::fabs(std::isinf(m_value) ? 0 : m_value)));
     }
 
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
+    void Approx::setMargin(double newMargin)
+    {
+      CATCH_ENFORCE(newMargin >= 0,
+                    "Invalid Approx::margin: " << newMargin << '.'
+                                               << " Approx::Margin has to be non-negative.");
+      m_margin = newMargin;
     }
 
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
+    void Approx::setEpsilon(double newEpsilon)
+    {
+      CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+                    "Invalid Approx::epsilon: " << newEpsilon << '.'
+                                                << " Approx::epsilon has to be in [0, 1]");
+      m_epsilon = newEpsilon;
     }
 
-} // end namespace Detail
+  } // end namespace Detail
 
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
+  namespace literals {
+    Detail::Approx operator"" _a(long double val) { return Detail::Approx(val); }
+    Detail::Approx operator"" _a(unsigned long long val) { return Detail::Approx(val); }
+  } // end namespace literals
 
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+  std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const &value)
+  {
     return value.toString();
-}
+  }
 
 } // end namespace Catch
 // end catch_approx.cpp
@@ -7622,35 +8472,40 @@ std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx co
 // start catch_debugger.h
 
 namespace Catch {
-    bool isDebuggerActive();
+  bool isDebuggerActive();
 }
 
 #ifdef CATCH_PLATFORM_MAC
 
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+#define CATCH_TRAP() __asm__("int $3\n" : :) /* NOLINT */
 
 #elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
+// If we can use inline assembler, do it because this allows us to break
+// directly at the location of the failing check instead of breaking inside
+// raise() called from it, i.e. one stack frame below.
+#if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+#define CATCH_TRAP() asm volatile("int $3") /* NOLINT */
+#else                                       // Fall back to the generic way.
+#include <signal.h>
+
+#define CATCH_TRAP() raise(SIGTRAP)
+#endif
 #elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
+#define CATCH_TRAP() __debugbreak()
 #elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
+extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+#define CATCH_TRAP() DebugBreak()
 #endif
 
 #ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+#define CATCH_BREAK_INTO_DEBUGGER()                                                                \
+  [] {                                                                                             \
+    if (Catch::isDebuggerActive()) {                                                               \
+      CATCH_TRAP();                                                                                \
+    }                                                                                              \
+  }()
 #else
-    #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+#define CATCH_BREAK_INTO_DEBUGGER() [] {}()
 #endif
 
 // end catch_debugger.h
@@ -7660,16 +8515,15 @@ namespace Catch {
 
 // start catch_windows_h_proxy.h
 
-
 #if defined(CATCH_PLATFORM_WINDOWS)
 
 #if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#  define CATCH_DEFINED_NOMINMAX
-#  define NOMINMAX
+#define CATCH_DEFINED_NOMINMAX
+#define NOMINMAX
 #endif
 #if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
+#define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
 #endif
 
 #ifdef __AFXDLL
@@ -7679,63 +8533,66 @@ namespace Catch {
 #endif
 
 #ifdef CATCH_DEFINED_NOMINMAX
-#  undef NOMINMAX
+#undef NOMINMAX
 #endif
 #ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
 #endif
 
 #endif // defined(CATCH_PLATFORM_WINDOWS)
 
 // end catch_windows_h_proxy.h
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
+#if defined(CATCH_CONFIG_WINDOWS_SEH)
 
 namespace Catch {
 
-    struct FatalConditionHandler {
+  struct FatalConditionHandler
+  {
 
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
+    static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
+    FatalConditionHandler();
+    static void reset();
+    ~FatalConditionHandler();
 
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
+  private:
+    static bool  isSet;
+    static ULONG guaranteeSize;
+    static PVOID exceptionHandlerHandle;
+  };
 
 } // namespace Catch
 
-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
+#elif defined(CATCH_CONFIG_POSIX_SIGNALS)
 
 #include <signal.h>
 
 namespace Catch {
 
-    struct FatalConditionHandler {
+  struct FatalConditionHandler
+  {
 
-        static bool isSet;
-        static struct sigaction oldSigActions[];
-        static stack_t oldSigStack;
-        static char altStackMem[];
+    static bool             isSet;
+    static struct sigaction oldSigActions[];
+    static stack_t          oldSigStack;
+    static char             altStackMem[];
 
-        static void handleSignal( int sig );
+    static void handleSignal(int sig);
 
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
+    FatalConditionHandler();
+    ~FatalConditionHandler();
+    static void reset();
+  };
 
 } // namespace Catch
 
 #else
 
 namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
+  struct FatalConditionHandler
+  {
+    void reset();
+  };
+} // namespace Catch
 
 #endif
 
@@ -7744,325 +8601,319 @@ namespace Catch {
 
 namespace Catch {
 
-    struct IMutableContext;
+  struct IMutableContext;
 
-    ///////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////
 
-    class RunContext : public IResultCapture, public IRunner {
+  class RunContext : public IResultCapture, public IRunner
+  {
 
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
-
-        ~RunContext() override;
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
-
-        Totals runTest(TestCase const& testCase);
-
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo const& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
-
-        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+  public:
+    RunContext(RunContext const &) = delete;
+    RunContext &operator=(RunContext const &) = delete;
+
+    explicit RunContext(IConfigPtr const &_config, IStreamingReporterPtr &&reporter);
+
+    ~RunContext() override;
+
+    void testGroupStarting(std::string const &testSpec, std::size_t groupIndex,
+                           std::size_t groupsCount);
+    void testGroupEnded(std::string const &testSpec, Totals const &totals, std::size_t groupIndex,
+                        std::size_t groupsCount);
+
+    Totals runTest(TestCase const &testCase);
+
+    IConfigPtr          config() const;
+    IStreamingReporter &reporter() const;
+
+  public: // IResultCapture
+    // Assertion handlers
+    void handleExpr(AssertionInfo const &info, ITransientExpression const &expr,
+                    AssertionReaction &reaction) override;
+    void handleMessage(AssertionInfo const &info, ResultWas::OfType resultType,
+                       StringRef const &message, AssertionReaction &reaction) override;
+    void handleUnexpectedExceptionNotThrown(AssertionInfo const &info,
+                                            AssertionReaction &  reaction) override;
+    void handleUnexpectedInflightException(AssertionInfo const &info, std::string const &message,
+                                           AssertionReaction &reaction) override;
+    void handleIncomplete(AssertionInfo const &info) override;
+    void handleNonExpr(AssertionInfo const &info, ResultWas::OfType resultType,
+                       AssertionReaction &reaction) override;
+
+    bool sectionStarted(SectionInfo const &sectionInfo, Counts &assertions) override;
+
+    void sectionEnded(SectionEndInfo const &endInfo) override;
+    void sectionEndedEarly(SectionEndInfo const &endInfo) override;
+
+    auto acquireGeneratorTracker(SourceLineInfo const &lineInfo) -> IGeneratorTracker & override;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing( std::string const& name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( std::string const& error ) override;
+    void benchmarkPreparing(std::string const &name) override;
+    void benchmarkStarting(BenchmarkInfo const &info) override;
+    void benchmarkEnded(BenchmarkStats<> const &stats) override;
+    void benchmarkFailed(std::string const &error) override;
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
+    void pushScopedMessage(MessageInfo const &message) override;
+    void popScopedMessage(MessageInfo const &message) override;
 
-        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+    void emplaceUnscopedMessage(MessageBuilder const &builder) override;
 
-        std::string getCurrentTestName() const override;
+    std::string getCurrentTestName() const override;
 
-        const AssertionResult* getLastResult() const override;
+    const AssertionResult *getLastResult() const override;
 
-        void exceptionEarlyReported() override;
+    void exceptionEarlyReported() override;
 
-        void handleFatalErrorCondition( StringRef message ) override;
+    void handleFatalErrorCondition(StringRef message) override;
 
-        bool lastAssertionPassed() override;
+    bool lastAssertionPassed() override;
 
-        void assertionPassed() override;
+    void assertionPassed() override;
 
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const final;
+  public:
+    // !TBD We need to do this another way!
+    bool aborting() const final;
 
-    private:
+  private:
+    void runCurrentTest(std::string &redirectedCout, std::string &redirectedCerr);
+    void invokeActiveTestCase();
 
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
-        void invokeActiveTestCase();
+    void resetAssertionInfo();
+    bool testForMissingAssertions(Counts &assertions);
 
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
+    void assertionEnded(AssertionResult const &result);
+    void reportExpr(AssertionInfo const &info, ResultWas::OfType resultType,
+                    ITransientExpression const *expr, bool negated);
 
-        void assertionEnded( AssertionResult const& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
+    void populateReaction(AssertionReaction &reaction);
 
-        void populateReaction( AssertionReaction& reaction );
+  private:
+    void handleUnfinishedSections();
 
-    private:
+    TestRunInfo             m_runInfo;
+    IMutableContext &       m_context;
+    TestCase const *        m_activeTestCase  = nullptr;
+    ITracker *              m_testCaseTracker = nullptr;
+    Option<AssertionResult> m_lastResult;
 
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Option<AssertionResult> m_lastResult;
-
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
+    IConfigPtr                  m_config;
+    Totals                      m_totals;
+    IStreamingReporterPtr       m_reporter;
+    std::vector<MessageInfo>    m_messages;
+    std::vector<ScopedMessage>  m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+    AssertionInfo               m_lastAssertionInfo;
+    std::vector<SectionEndInfo> m_unfinishedSections;
+    std::vector<ITracker *>     m_activeSections;
+    TrackerContext              m_trackerContext;
+    bool                        m_lastAssertionPassed    = false;
+    bool                        m_shouldReportUnexpected = true;
+    bool                        m_includeSuccessfulResults;
+  };
 
+  void         seedRng(IConfig const &config);
+  unsigned int rngSeed();
 } // end namespace Catch
 
 // end catch_run_context.h
 namespace Catch {
 
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
+  namespace {
+    auto operator<<(std::ostream &os, ITransientExpression const &expr) -> std::ostream &
+    {
+      expr.streamReconstructedExpression(os);
+      return os;
     }
+  } // namespace
 
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
+  LazyExpression::LazyExpression(bool isNegated) : m_isNegated(isNegated) {}
 
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
+  LazyExpression::LazyExpression(LazyExpression const &other) : m_isNegated(other.m_isNegated) {}
 
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
+  LazyExpression::operator bool() const { return m_transientExpression != nullptr; }
 
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
+  auto operator<<(std::ostream &os, LazyExpression const &lazyExpr) -> std::ostream &
+  {
+    if (lazyExpr.m_isNegated)
+      os << "!";
 
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
+    if (lazyExpr) {
+      if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
+        os << "(" << *lazyExpr.m_transientExpression << ")";
+      else
+        os << *lazyExpr.m_transientExpression;
     }
+    else {
+      os << "{** error - unchecked empty expression requested **}";
+    }
+    return os;
+  }
 
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
+  AssertionHandler::AssertionHandler(StringRef const &macroName, SourceLineInfo const &lineInfo,
+                                     StringRef                capturedExpression,
+                                     ResultDisposition::Flags resultDisposition)
+      : m_assertionInfo{macroName, lineInfo, capturedExpression, resultDisposition},
+        m_resultCapture(getResultCapture())
+  {
+  }
 
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
+  void AssertionHandler::handleExpr(ITransientExpression const &expr)
+  {
+    m_resultCapture.handleExpr(m_assertionInfo, expr, m_reaction);
+  }
+  void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const &message)
+  {
+    m_resultCapture.handleMessage(m_assertionInfo, resultType, message, m_reaction);
+  }
 
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
+  auto AssertionHandler::allowThrows() const -> bool
+  {
+    return getCurrentContext().getConfig()->allowThrows();
+  }
 
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
+  void AssertionHandler::complete()
+  {
+    setCompleted();
+    if (m_reaction.shouldDebugBreak) {
 
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
+      // If you find your debugger stopping you here then go one level up on the
+      // call-stack for the code that caused it (typically a failed assertion)
 
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
+      // (To go back to the test and change execution, jump over the throw, next)
+      CATCH_BREAK_INTO_DEBUGGER();
+    }
+    if (m_reaction.shouldThrow) {
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
+      throw Catch::TestFailureException();
 #else
-            CATCH_ERROR( "Test failure requires aborting test!" );
+      CATCH_ERROR("Test failure requires aborting test!");
 #endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
     }
+  }
+  void AssertionHandler::setCompleted() { m_completed = true; }
 
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
+  void AssertionHandler::handleUnexpectedInflightException()
+  {
+    m_resultCapture.handleUnexpectedInflightException(
+        m_assertionInfo, Catch::translateActiveException(), m_reaction);
+  }
 
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
+  void AssertionHandler::handleExceptionThrownAsExpected()
+  {
+    m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+  }
+  void AssertionHandler::handleExceptionNotThrownAsExpected()
+  {
+    m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+  }
 
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
+  void AssertionHandler::handleUnexpectedExceptionNotThrown()
+  {
+    m_resultCapture.handleUnexpectedExceptionNotThrown(m_assertionInfo, m_reaction);
+  }
 
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
+  void AssertionHandler::handleThrowingCallSkipped()
+  {
+    m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+  }
 
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
+  // This is the overload that takes a string and infers the Equals matcher from it
+  // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+  void handleExceptionMatchExpr(AssertionHandler &handler, std::string const &str,
+                                StringRef const &matcherString)
+  {
+    handleExceptionMatchExpr(handler, Matchers::Equals(str), matcherString);
+  }
 
 } // namespace Catch
 // end catch_assertionhandler.cpp
 // start catch_assertionresult.cpp
 
 namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
+  AssertionResultData::AssertionResultData(ResultWas::OfType     _resultType,
+                                           LazyExpression const &_lazyExpression)
+      : lazyExpression(_lazyExpression), resultType(_resultType)
+  {
+  }
 
-    std::string AssertionResultData::reconstructExpression() const {
+  std::string AssertionResultData::reconstructExpression() const
+  {
 
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
+    if (reconstructedExpression.empty()) {
+      if (lazyExpression) {
+        ReusableStringStream rss;
+        rss << lazyExpression;
+        reconstructedExpression = rss.str();
+      }
     }
+    return reconstructedExpression;
+  }
+
+  AssertionResult::AssertionResult(AssertionInfo const &info, AssertionResultData const &data)
+      : m_info(info), m_resultData(data)
+  {
+  }
 
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
+  // Result was a success
+  bool AssertionResult::succeeded() const { return Catch::isOk(m_resultData.resultType); }
 
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
+  // Result was a success, or failure is suppressed
+  bool AssertionResult::isOk() const
+  {
+    return Catch::isOk(m_resultData.resultType) || shouldSuppressFailure(m_info.resultDisposition);
+  }
 
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
+  ResultWas::OfType AssertionResult::getResultType() const { return m_resultData.resultType; }
 
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
+  bool AssertionResult::hasExpression() const { return !m_info.capturedExpression.empty(); }
 
-    bool AssertionResult::hasExpression() const {
-        return m_info.capturedExpression[0] != 0;
-    }
+  bool AssertionResult::hasMessage() const { return !m_resultData.message.empty(); }
 
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
+  std::string AssertionResult::getExpression() const
+  {
+    // Possibly overallocating by 3 characters should be basically free
+    std::string expr;
+    expr.reserve(m_info.capturedExpression.size() + 3);
+    if (isFalseTest(m_info.resultDisposition)) {
+      expr += "!(";
     }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + m_info.capturedExpression + ")";
-        else
-            return m_info.capturedExpression;
+    expr += m_info.capturedExpression;
+    if (isFalseTest(m_info.resultDisposition)) {
+      expr += ')';
     }
+    return expr;
+  }
 
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName[0] == 0 )
-            expr = m_info.capturedExpression;
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
+  std::string AssertionResult::getExpressionInMacro() const
+  {
+    std::string expr;
+    if (m_info.macroName.empty())
+      expr = static_cast<std::string>(m_info.capturedExpression);
+    else {
+      expr.reserve(m_info.macroName.size() + m_info.capturedExpression.size() + 4);
+      expr += m_info.macroName;
+      expr += "( ";
+      expr += m_info.capturedExpression;
+      expr += " )";
+    }
+    return expr;
+  }
 
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
+  bool AssertionResult::hasExpandedExpression() const
+  {
+    return hasExpression() && getExpandedExpression() != getExpression();
+  }
 
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
+  std::string AssertionResult::getExpandedExpression() const
+  {
+    std::string expr = m_resultData.reconstructExpression();
+    return expr.empty() ? getExpression() : expr;
+  }
 
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
+  std::string    AssertionResult::getMessage() const { return m_resultData.message; }
+  SourceLineInfo AssertionResult::getSourceInfo() const { return m_info.lineInfo; }
 
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
+  StringRef AssertionResult::getTestMacroName() const { return m_info.macroName; }
 
 } // end namespace Catch
 // end catch_assertionresult.cpp
@@ -8070,16 +8921,18 @@ namespace Catch {
 
 namespace Catch {
 
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
+  using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+  // This is the general overload that takes a any string matcher
+  // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and
+  // infers the Equals matcher (so the header does not mention matchers)
+  void handleExceptionMatchExpr(AssertionHandler &handler, StringMatcher const &matcher,
+                                StringRef const &matcherString)
+  {
+    std::string exceptionMessage = Catch::translateActiveException();
+    MatchExpr<std::string, StringMatcher const &> expr(exceptionMessage, matcher, matcherString);
+    handler.handleExpr(expr);
+  }
 
 } // namespace Catch
 // end catch_capture_matchers.cpp
@@ -8094,7 +8947,7 @@ namespace Catch {
 #define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
 #undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
 #endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH - 1
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ -8113,7 +8966,6 @@ namespace Catch {
 
 // Clara v1.1.5
 
-
 #ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
 #define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
 #endif
@@ -8142,7 +8994,6 @@ namespace Catch {
 //
 // This project is hosted at https://github.com/philsquared/textflowcpp
 
-
 #include <cassert>
 #include <ostream>
 #include <sstream>
@@ -8153,1210 +9004,1334 @@ namespace Catch {
 #endif
 
 namespace Catch {
-namespace clara {
-namespace TextFlow {
+  namespace clara {
+    namespace TextFlow {
+
+      inline auto isWhitespace(char c) -> bool
+      {
+        static std::string chars = " \t\n\r";
+        return chars.find(c) != std::string::npos;
+      }
+      inline auto isBreakableBefore(char c) -> bool
+      {
+        static std::string chars = "[({<|";
+        return chars.find(c) != std::string::npos;
+      }
+      inline auto isBreakableAfter(char c) -> bool
+      {
+        static std::string chars = "])}>.,:;*+-=&/\\";
+        return chars.find(c) != std::string::npos;
+      }
+
+      class Columns;
+
+      class Column
+      {
+        std::vector<std::string> m_strings;
+        size_t                   m_width         = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+        size_t                   m_indent        = 0;
+        size_t                   m_initialIndent = std::string::npos;
+
+      public:
+        class iterator
+        {
+          friend Column;
+
+          Column const &m_column;
+          size_t        m_stringIndex = 0;
+          size_t        m_pos         = 0;
+
+          size_t m_len    = 0;
+          size_t m_end    = 0;
+          bool   m_suffix = false;
+
+          iterator(Column const &column, size_t stringIndex)
+              : m_column(column), m_stringIndex(stringIndex)
+          {
+          }
+
+          auto line() const -> std::string const & { return m_column.m_strings[m_stringIndex]; }
+
+          auto isBoundary(size_t at) const -> bool
+          {
+            assert(at > 0);
+            assert(at <= line().size());
+
+            return at == line().size() ||
+                   (isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+                   isBreakableBefore(line()[at]) || isBreakableAfter(line()[at - 1]);
+          }
+
+          void calcLength()
+          {
+            assert(m_stringIndex < m_column.m_strings.size());
+
+            m_suffix   = false;
+            auto width = m_column.m_width - indent();
+            m_end      = m_pos;
+            if (line()[m_pos] == '\n') {
+              ++m_end;
+            }
+            while (m_end < line().size() && line()[m_end] != '\n')
+              ++m_end;
 
-inline auto isWhitespace(char c) -> bool {
-	static std::string chars = " \t\n\r";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableBefore(char c) -> bool {
-	static std::string chars = "[({<|";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableAfter(char c) -> bool {
-	static std::string chars = "])}>.,:;*+-=&/\\";
-	return chars.find(c) != std::string::npos;
-}
+            if (m_end < m_pos + width) {
+              m_len = m_end - m_pos;
+            }
+            else {
+              size_t len = width;
+              while (len > 0 && !isBoundary(m_pos + len))
+                --len;
+              while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+                --len;
+
+              if (len > 0) {
+                m_len = len;
+              }
+              else {
+                m_suffix = true;
+                m_len    = width - 1;
+              }
+            }
+          }
 
-class Columns;
-
-class Column {
-	std::vector<std::string> m_strings;
-	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-	size_t m_indent = 0;
-	size_t m_initialIndent = std::string::npos;
-
-public:
-	class iterator {
-		friend Column;
-
-		Column const& m_column;
-		size_t m_stringIndex = 0;
-		size_t m_pos = 0;
-
-		size_t m_len = 0;
-		size_t m_end = 0;
-		bool m_suffix = false;
-
-		iterator(Column const& column, size_t stringIndex)
-			: m_column(column),
-			m_stringIndex(stringIndex) {}
-
-		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-		auto isBoundary(size_t at) const -> bool {
-			assert(at > 0);
-			assert(at <= line().size());
-
-			return at == line().size() ||
-				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-				isBreakableBefore(line()[at]) ||
-				isBreakableAfter(line()[at - 1]);
-		}
-
-		void calcLength() {
-			assert(m_stringIndex < m_column.m_strings.size());
-
-			m_suffix = false;
-			auto width = m_column.m_width - indent();
-			m_end = m_pos;
-			if (line()[m_pos] == '\n') {
-				++m_end;
-			}
-			while (m_end < line().size() && line()[m_end] != '\n')
-				++m_end;
-
-			if (m_end < m_pos + width) {
-				m_len = m_end - m_pos;
-			} else {
-				size_t len = width;
-				while (len > 0 && !isBoundary(m_pos + len))
-					--len;
-				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
-					--len;
-
-				if (len > 0) {
-					m_len = len;
-				} else {
-					m_suffix = true;
-					m_len = width - 1;
-				}
-			}
-		}
-
-		auto indent() const -> size_t {
-			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-			return initial == std::string::npos ? m_column.m_indent : initial;
-		}
-
-		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Column const& column) : m_column(column) {
-			assert(m_column.m_width > m_column.m_indent);
-			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
-			calcLength();
-			if (m_len == 0)
-				m_stringIndex++; // Empty string
-		}
-
-		auto operator *() const -> std::string {
-			assert(m_stringIndex < m_column.m_strings.size());
-			assert(m_pos <= m_end);
-			return addIndentAndSuffix(line().substr(m_pos, m_len));
-		}
-
-		auto operator ++() -> iterator& {
-			m_pos += m_len;
-			if (m_pos < line().size() && line()[m_pos] == '\n')
-				m_pos += 1;
-			else
-				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
-					++m_pos;
-
-			if (m_pos == line().size()) {
-				m_pos = 0;
-				++m_stringIndex;
-			}
-			if (m_stringIndex < m_column.m_strings.size())
-				calcLength();
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return
-				m_pos == other.m_pos &&
-				m_stringIndex == other.m_stringIndex &&
-				&m_column == &other.m_column;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return !operator==(other);
-		}
-	};
-	using const_iterator = iterator;
-
-	explicit Column(std::string const& text) { m_strings.push_back(text); }
-
-	auto width(size_t newWidth) -> Column& {
-		assert(newWidth > 0);
-		m_width = newWidth;
-		return *this;
-	}
-	auto indent(size_t newIndent) -> Column& {
-		m_indent = newIndent;
-		return *this;
-	}
-	auto initialIndent(size_t newIndent) -> Column& {
-		m_initialIndent = newIndent;
-		return *this;
-	}
-
-	auto width() const -> size_t { return m_width; }
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
-		bool first = true;
-		for (auto line : col) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto operator + (Column const& other)->Columns;
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
+          auto indent() const -> size_t
+          {
+            auto initial =
+                m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+            return initial == std::string::npos ? m_column.m_indent : initial;
+          }
 
-class Spacer : public Column {
+          auto addIndentAndSuffix(std::string const &plain) const -> std::string
+          {
+            return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+          }
 
-public:
-	explicit Spacer(size_t spaceWidth) : Column("") {
-		width(spaceWidth);
-	}
-};
+        public:
+          using difference_type   = std::ptrdiff_t;
+          using value_type        = std::string;
+          using pointer           = value_type *;
+          using reference         = value_type &;
+          using iterator_category = std::forward_iterator_tag;
+
+          explicit iterator(Column const &column) : m_column(column)
+          {
+            assert(m_column.m_width > m_column.m_indent);
+            assert(m_column.m_initialIndent == std::string::npos ||
+                   m_column.m_width > m_column.m_initialIndent);
+            calcLength();
+            if (m_len == 0)
+              m_stringIndex++; // Empty string
+          }
+
+          auto operator*() const -> std::string
+          {
+            assert(m_stringIndex < m_column.m_strings.size());
+            assert(m_pos <= m_end);
+            return addIndentAndSuffix(line().substr(m_pos, m_len));
+          }
+
+          auto operator++() -> iterator &
+          {
+            m_pos += m_len;
+            if (m_pos < line().size() && line()[m_pos] == '\n')
+              m_pos += 1;
+            else
+              while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+                ++m_pos;
 
-class Columns {
-	std::vector<Column> m_columns;
-
-public:
-
-	class iterator {
-		friend Columns;
-		struct EndTag {};
-
-		std::vector<Column> const& m_columns;
-		std::vector<Column::iterator> m_iterators;
-		size_t m_activeIterators;
-
-		iterator(Columns const& columns, EndTag)
-			: m_columns(columns.m_columns),
-			m_activeIterators(0) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.end());
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Columns const& columns)
-			: m_columns(columns.m_columns),
-			m_activeIterators(m_columns.size()) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.begin());
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return m_iterators == other.m_iterators;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return m_iterators != other.m_iterators;
-		}
-		auto operator *() const -> std::string {
-			std::string row, padding;
-
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				auto width = m_columns[i].width();
-				if (m_iterators[i] != m_columns[i].end()) {
-					std::string col = *m_iterators[i];
-					row += padding + col;
-					if (col.size() < width)
-						padding = std::string(width - col.size(), ' ');
-					else
-						padding = "";
-				} else {
-					padding += std::string(width, ' ');
-				}
-			}
-			return row;
-		}
-		auto operator ++() -> iterator& {
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				if (m_iterators[i] != m_columns[i].end())
-					++m_iterators[i];
-			}
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-	};
-	using const_iterator = iterator;
-
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-	auto operator += (Column const& col) -> Columns& {
-		m_columns.push_back(col);
-		return *this;
-	}
-	auto operator + (Column const& col) -> Columns {
-		Columns combined = *this;
-		combined += col;
-		return combined;
-	}
-
-	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
-
-		bool first = true;
-		for (auto line : cols) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
+            if (m_pos == line().size()) {
+              m_pos = 0;
+              ++m_stringIndex;
+            }
+            if (m_stringIndex < m_column.m_strings.size())
+              calcLength();
+            return *this;
+          }
+          auto operator++(int) -> iterator
+          {
+            iterator prev(*this);
+                     operator++();
+            return prev;
+          }
+
+          auto operator==(iterator const &other) const -> bool
+          {
+            return m_pos == other.m_pos && m_stringIndex == other.m_stringIndex &&
+                   &m_column == &other.m_column;
+          }
+          auto operator!=(iterator const &other) const -> bool { return !operator==(other); }
+        };
+        using const_iterator = iterator;
 
-inline auto Column::operator + (Column const& other) -> Columns {
-	Columns cols;
-	cols += *this;
-	cols += other;
-	return cols;
-}
-}
+        explicit Column(std::string const &text) { m_strings.push_back(text); }
 
-}
-}
+        auto width(size_t newWidth) -> Column &
+        {
+          assert(newWidth > 0);
+          m_width = newWidth;
+          return *this;
+        }
+        auto indent(size_t newIndent) -> Column &
+        {
+          m_indent = newIndent;
+          return *this;
+        }
+        auto initialIndent(size_t newIndent) -> Column &
+        {
+          m_initialIndent = newIndent;
+          return *this;
+        }
+
+        auto width() const -> size_t { return m_width; }
+        auto begin() const -> iterator { return iterator(*this); }
+        auto end() const -> iterator { return {*this, m_strings.size()}; }
+
+        inline friend std::ostream &operator<<(std::ostream &os, Column const &col)
+        {
+          bool first = true;
+          for (auto line : col) {
+            if (first)
+              first = false;
+            else
+              os << "\n";
+            os << line;
+          }
+          return os;
+        }
+
+        auto operator+(Column const &other) -> Columns;
+
+        auto toString() const -> std::string
+        {
+          std::ostringstream oss;
+          oss << *this;
+          return oss.str();
+        }
+      };
+
+      class Spacer : public Column
+      {
+
+      public:
+        explicit Spacer(size_t spaceWidth) : Column("") { width(spaceWidth); }
+      };
+
+      class Columns
+      {
+        std::vector<Column> m_columns;
+
+      public:
+        class iterator
+        {
+          friend Columns;
+          struct EndTag
+          {
+          };
+
+          std::vector<Column> const &   m_columns;
+          std::vector<Column::iterator> m_iterators;
+          size_t                        m_activeIterators;
+
+          iterator(Columns const &columns, EndTag)
+              : m_columns(columns.m_columns), m_activeIterators(0)
+          {
+            m_iterators.reserve(m_columns.size());
+
+            for (auto const &col : m_columns)
+              m_iterators.push_back(col.end());
+          }
+
+        public:
+          using difference_type   = std::ptrdiff_t;
+          using value_type        = std::string;
+          using pointer           = value_type *;
+          using reference         = value_type &;
+          using iterator_category = std::forward_iterator_tag;
+
+          explicit iterator(Columns const &columns)
+              : m_columns(columns.m_columns), m_activeIterators(m_columns.size())
+          {
+            m_iterators.reserve(m_columns.size());
+
+            for (auto const &col : m_columns)
+              m_iterators.push_back(col.begin());
+          }
+
+          auto operator==(iterator const &other) const -> bool
+          {
+            return m_iterators == other.m_iterators;
+          }
+          auto operator!=(iterator const &other) const -> bool
+          {
+            return m_iterators != other.m_iterators;
+          }
+          auto operator*() const -> std::string
+          {
+            std::string row, padding;
+
+            for (size_t i = 0; i < m_columns.size(); ++i) {
+              auto width = m_columns[i].width();
+              if (m_iterators[i] != m_columns[i].end()) {
+                std::string col = *m_iterators[i];
+                row += padding + col;
+                if (col.size() < width)
+                  padding = std::string(width - col.size(), ' ');
+                else
+                  padding = "";
+              }
+              else {
+                padding += std::string(width, ' ');
+              }
+            }
+            return row;
+          }
+          auto operator++() -> iterator &
+          {
+            for (size_t i = 0; i < m_columns.size(); ++i) {
+              if (m_iterators[i] != m_columns[i].end())
+                ++m_iterators[i];
+            }
+            return *this;
+          }
+          auto operator++(int) -> iterator
+          {
+            iterator prev(*this);
+                     operator++();
+            return prev;
+          }
+        };
+        using const_iterator = iterator;
+
+        auto begin() const -> iterator { return iterator(*this); }
+        auto end() const -> iterator { return {*this, iterator::EndTag()}; }
+
+        auto operator+=(Column const &col) -> Columns &
+        {
+          m_columns.push_back(col);
+          return *this;
+        }
+        auto operator+(Column const &col) -> Columns
+        {
+          Columns combined = *this;
+          combined += col;
+          return combined;
+        }
+
+        inline friend std::ostream &operator<<(std::ostream &os, Columns const &cols)
+        {
+
+          bool first = true;
+          for (auto line : cols) {
+            if (first)
+              first = false;
+            else
+              os << "\n";
+            os << line;
+          }
+          return os;
+        }
+
+        auto toString() const -> std::string
+        {
+          std::ostringstream oss;
+          oss << *this;
+          return oss.str();
+        }
+      };
+
+      inline auto Column::operator+(Column const &other) -> Columns
+      {
+        Columns cols;
+        cols += *this;
+        cols += other;
+        return cols;
+      }
+    } // namespace TextFlow
+
+  } // namespace clara
+} // namespace Catch
 
 // ----------- end of #include from clara_textflow.hpp -----------
 // ........... back in clara.hpp
 
+#include <algorithm>
 #include <cctype>
-#include <string>
 #include <memory>
 #include <set>
-#include <algorithm>
+#include <string>
 
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#if !defined(CATCH_PLATFORM_WINDOWS) &&                                                            \
+    (defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER))
 #define CATCH_PLATFORM_WINDOWS
 #endif
 
-namespace Catch { namespace clara {
-namespace detail {
+namespace Catch {
+  namespace clara {
+    namespace detail {
 
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+      // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+      template <typename L> struct UnaryLambdaTraits : UnaryLambdaTraits<decltype(&L::operator())>
+      {
+      };
 
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+      template <typename ClassT, typename ReturnT, typename... Args>
+      struct UnaryLambdaTraits<ReturnT (ClassT::*)(Args...) const>
+      {
         static const bool isValid = false;
-    };
+      };
 
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+      template <typename ClassT, typename ReturnT, typename ArgT>
+      struct UnaryLambdaTraits<ReturnT (ClassT::*)(ArgT) const>
+      {
         static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ArgType =
+            typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
         using ReturnType = ReturnT;
-    };
+      };
 
-    class TokenStream;
+      class TokenStream;
 
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
+      // Transport for raw args (copied from main args, or supplied via init list for testing)
+      class Args
+      {
         friend TokenStream;
-        std::string m_exeName;
+        std::string              m_exeName;
         std::vector<std::string> m_args;
 
-    public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
+      public:
+        Args(int argc, char const *const *argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc)
+        {
+        }
 
-        auto exeName() const -> std::string {
-            return m_exeName;
+        Args(std::initializer_list<std::string> args)
+            : m_exeName(*args.begin()), m_args(args.begin() + 1, args.end())
+        {
         }
-    };
 
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
+        auto exeName() const -> std::string { return m_exeName; }
+      };
+
+      // Wraps a token coming from a token stream. These may not directly correspond to strings as a
+      // single string may encode an option + its argument if the : or = form is used
+      enum class TokenType { Option, Argument };
+      struct Token
+      {
+        TokenType   type;
         std::string token;
-    };
+      };
 
-    inline auto isOptPrefix( char c ) -> bool {
+      inline auto isOptPrefix(char c) -> bool
+      {
         return c == '-'
 #ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
+               || c == '/'
 #endif
-        ;
-    }
+            ;
+      }
 
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
+      // Abstracts iterators into args as a stream of tokens, with option arguments uniformly
+      // handled
+      class TokenStream
+      {
         using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
+        Iterator           it;
+        Iterator           itEnd;
         std::vector<Token> m_tokenBuffer;
 
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+        void loadBuffer()
+        {
+          m_tokenBuffer.resize(0);
+
+          // Skip any empty strings
+          while (it != itEnd && it->empty())
+            ++it;
+
+          if (it != itEnd) {
+            auto const &next = *it;
+            if (isOptPrefix(next[0])) {
+              auto delimiterPos = next.find_first_of(" :=");
+              if (delimiterPos != std::string::npos) {
+                m_tokenBuffer.push_back({TokenType::Option, next.substr(0, delimiterPos)});
+                m_tokenBuffer.push_back({TokenType::Argument, next.substr(delimiterPos + 1)});
+              }
+              else {
+                if (next[1] != '-' && next.size() > 2) {
+                  std::string opt = "- ";
+                  for (size_t i = 1; i < next.size(); ++i) {
+                    opt[1] = next[i];
+                    m_tokenBuffer.push_back({TokenType::Option, opt});
+                  }
                 }
+                else {
+                  m_tokenBuffer.push_back({TokenType::Option, next});
+                }
+              }
+            }
+            else {
+              m_tokenBuffer.push_back({TokenType::Argument, next});
             }
+          }
         }
 
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
+      public:
+        explicit TokenStream(Args const &args) : TokenStream(args.m_args.begin(), args.m_args.end())
+        {
         }
 
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
+        TokenStream(Iterator it, Iterator itEnd) : it(it), itEnd(itEnd) { loadBuffer(); }
+
+        explicit operator bool() const { return !m_tokenBuffer.empty() || it != itEnd; }
 
         auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
 
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
+        auto operator*() const -> Token
+        {
+          assert(!m_tokenBuffer.empty());
+          return m_tokenBuffer.front();
         }
 
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
+        auto operator-> () const -> Token const *
+        {
+          assert(!m_tokenBuffer.empty());
+          return &m_tokenBuffer.front();
         }
 
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
+        auto operator++() -> TokenStream &
+        {
+          if (m_tokenBuffer.size() >= 2) {
+            m_tokenBuffer.erase(m_tokenBuffer.begin());
+          }
+          else {
+            if (it != itEnd)
+              ++it;
+            loadBuffer();
+          }
+          return *this;
         }
-    };
+      };
 
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
+      class ResultBase
+      {
+      public:
+        enum Type { Ok, LogicError, RuntimeError };
 
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
+      protected:
+        ResultBase(Type type) : m_type(type) {}
         virtual ~ResultBase() = default;
 
         virtual void enforceOk() const = 0;
 
         Type m_type;
-    };
+      };
 
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
+      template <typename T> class ResultValueBase : public ResultBase
+      {
+      public:
+        auto value() const -> T const &
+        {
+          enforceOk();
+          return m_value;
         }
 
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
+      protected:
+        ResultValueBase(Type type) : ResultBase(type) {}
 
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
+        ResultValueBase(ResultValueBase const &other) : ResultBase(other)
+        {
+          if (m_type == ResultBase::Ok)
+            new (&m_value) T(other.m_value);
         }
 
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
+        ResultValueBase(Type, T const &value) : ResultBase(Ok) { new (&m_value) T(value); }
 
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
+        auto operator=(ResultValueBase const &other) -> ResultValueBase &
+        {
+          if (m_type == ResultBase::Ok)
+            m_value.~T();
+          ResultBase::operator=(other);
+          if (m_type == ResultBase::Ok)
+            new (&m_value) T(other.m_value);
+          return *this;
         }
 
-        ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
+        ~ResultValueBase() override
+        {
+          if (m_type == Ok)
+            m_value.~T();
         }
 
         union {
-            T m_value;
+          T m_value;
         };
-    };
+      };
 
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
+      template <> class ResultValueBase<void> : public ResultBase
+      {
+      protected:
         using ResultBase::ResultBase;
-    };
+      };
 
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
+      template <typename T = void> class BasicResult : public ResultValueBase<T>
+      {
+      public:
+        template <typename U>
+        explicit BasicResult(BasicResult<U> const &other)
+            : ResultValueBase<T>(other.type()), m_errorMessage(other.errorMessage())
         {
-            assert( type() != ResultBase::Ok );
+          assert(type() != ResultBase::Ok);
         }
 
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+        template <typename U> static auto ok(U const &value) -> BasicResult
+        {
+          return {ResultBase::Ok, value};
+        }
+        static auto ok() -> BasicResult { return {ResultBase::Ok}; }
+        static auto logicError(std::string const &message) -> BasicResult
+        {
+          return {ResultBase::LogicError, message};
+        }
+        static auto runtimeError(std::string const &message) -> BasicResult
+        {
+          return {ResultBase::RuntimeError, message};
+        }
 
         explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
+        auto     type() const -> ResultBase::Type { return m_type; }
+        auto     errorMessage() const -> std::string { return m_errorMessage; }
 
-    protected:
-        void enforceOk() const override {
-
-            // Errors shouldn't reach this point, but if they do
-            // the actual error message will be in m_errorMessage
-            assert( m_type != ResultBase::LogicError );
-            assert( m_type != ResultBase::RuntimeError );
-            if( m_type != ResultBase::Ok )
-                std::abort();
+      protected:
+        void enforceOk() const override
+        {
+
+          // Errors shouldn't reach this point, but if they do
+          // the actual error message will be in m_errorMessage
+          assert(m_type != ResultBase::LogicError);
+          assert(m_type != ResultBase::RuntimeError);
+          if (m_type != ResultBase::Ok)
+            std::abort();
         }
 
         std::string m_errorMessage; // Only populated if resultType is an error
 
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
+        BasicResult(ResultBase::Type type, std::string const &message)
+            : ResultValueBase<T>(type), m_errorMessage(message)
         {
-            assert( m_type != ResultBase::Ok );
+          assert(m_type != ResultBase::Ok);
         }
 
         using ResultValueBase<T>::ResultValueBase;
         using ResultBase::m_type;
-    };
+      };
 
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
+      enum class ParseResultType { Matched, NoMatch, ShortCircuitAll, ShortCircuitSame };
 
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
+      class ParseState
+      {
+      public:
+        ParseState(ParseResultType type, TokenStream const &remainingTokens)
+            : m_type(type), m_remainingTokens(remainingTokens)
+        {
+        }
 
         auto type() const -> ParseResultType { return m_type; }
         auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
 
-    private:
+      private:
         ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
+        TokenStream     m_remainingTokens;
+      };
 
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
+      using Result              = BasicResult<void>;
+      using ParserResult        = BasicResult<ParseResultType>;
+      using InternalParseResult = BasicResult<ParseState>;
 
-    struct HelpColumns {
+      struct HelpColumns
+      {
         std::string left;
         std::string right;
-    };
+      };
 
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+      template <typename T>
+      inline auto convertInto(std::string const &source, T &target) -> ParserResult
+      {
         std::stringstream ss;
         ss << source;
         ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        if (ss.fail())
+          return ParserResult::runtimeError("Unable to convert '" + source +
+                                            "' to destination type");
         else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+          return ParserResult::ok(ParseResultType::Matched);
+      }
+      inline auto convertInto(std::string const &source, std::string &target) -> ParserResult
+      {
         target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        return ParserResult::ok(ParseResultType::Matched);
+      }
+      inline auto convertInto(std::string const &source, bool &target) -> ParserResult
+      {
         std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
+        std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(),
+                       [](char c) { return static_cast<char>(std::tolower(c)); });
         if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
+          target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" ||
+                 srcLC == "off")
+          target = false;
         else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
+          return ParserResult::runtimeError("Expected a boolean value but did not recognise: '" +
+                                            source + "'");
+        return ParserResult::ok(ParseResultType::Matched);
+      }
 #ifdef CLARA_CONFIG_OPTIONAL_TYPE
-    template<typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
-        T temp;
-        auto result = convertInto( source, temp );
-        if( result )
-            target = std::move(temp);
+      template <typename T>
+      inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T> &target)
+          -> ParserResult
+      {
+        T    temp;
+        auto result = convertInto(source, temp);
+        if (result)
+          target = std::move(temp);
         return result;
-    }
+      }
 #endif // CLARA_CONFIG_OPTIONAL_TYPE
 
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable( NonCopyable const & ) = delete;
-        NonCopyable( NonCopyable && ) = delete;
-        NonCopyable &operator=( NonCopyable const & ) = delete;
-        NonCopyable &operator=( NonCopyable && ) = delete;
-    };
-
-    struct BoundRef : NonCopyable {
+      struct NonCopyable
+      {
+        NonCopyable()                    = default;
+        NonCopyable(NonCopyable const &) = delete;
+        NonCopyable(NonCopyable &&)      = delete;
+        NonCopyable &operator=(NonCopyable const &) = delete;
+        NonCopyable &operator=(NonCopyable &&) = delete;
+      };
+
+      struct BoundRef : NonCopyable
+      {
         virtual ~BoundRef() = default;
         virtual auto isContainer() const -> bool { return false; }
         virtual auto isFlag() const -> bool { return false; }
-    };
-    struct BoundValueRefBase : BoundRef {
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-    };
-    struct BoundFlagRefBase : BoundRef {
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+      };
+      struct BoundValueRefBase : BoundRef
+      {
+        virtual auto setValue(std::string const &arg) -> ParserResult = 0;
+      };
+      struct BoundFlagRefBase : BoundRef
+      {
+        virtual auto setFlag(bool flag) -> ParserResult = 0;
         virtual auto isFlag() const -> bool { return true; }
-    };
+      };
 
-    template<typename T>
-    struct BoundValueRef : BoundValueRefBase {
+      template <typename T> struct BoundValueRef : BoundValueRefBase
+      {
         T &m_ref;
 
-        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+        explicit BoundValueRef(T &ref) : m_ref(ref) {}
 
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
+        auto setValue(std::string const &arg) -> ParserResult override
+        {
+          return convertInto(arg, m_ref);
         }
-    };
+      };
 
-    template<typename T>
-    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+      template <typename T> struct BoundValueRef<std::vector<T>> : BoundValueRefBase
+      {
         std::vector<T> &m_ref;
 
-        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+        explicit BoundValueRef(std::vector<T> &ref) : m_ref(ref) {}
 
         auto isContainer() const -> bool override { return true; }
 
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
+        auto setValue(std::string const &arg) -> ParserResult override
+        {
+          T    temp;
+          auto result = convertInto(arg, temp);
+          if (result)
+            m_ref.push_back(temp);
+          return result;
         }
-    };
+      };
 
-    struct BoundFlagRef : BoundFlagRefBase {
+      struct BoundFlagRef : BoundFlagRefBase
+      {
         bool &m_ref;
 
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+        explicit BoundFlagRef(bool &ref) : m_ref(ref) {}
 
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
+        auto setFlag(bool flag) -> ParserResult override
+        {
+          m_ref = flag;
+          return ParserResult::ok(ParseResultType::Matched);
         }
-    };
+      };
 
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+      template <typename ReturnType> struct LambdaInvoker
+      {
+        static_assert(std::is_same<ReturnType, ParserResult>::value,
+                      "Lambda must return void or clara::ParserResult");
 
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
+        template <typename L, typename ArgType>
+        static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult
+        {
+          return lambda(arg);
         }
-    };
+      };
 
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
+      template <> struct LambdaInvoker<void>
+      {
+        template <typename L, typename ArgType>
+        static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult
+        {
+          lambda(arg);
+          return ParserResult::ok(ParseResultType::Matched);
         }
-    };
+      };
 
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+      template <typename ArgType, typename L>
+      inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult
+      {
         ArgType temp{};
-        auto result = convertInto( arg, temp );
+        auto    result = convertInto(arg, temp);
         return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    }
+                   ? result
+                   : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(lambda, temp);
+      }
 
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
+      template <typename L> struct BoundLambda : BoundValueRefBase
+      {
         L m_lambda;
 
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+        static_assert(UnaryLambdaTraits<L>::isValid,
+                      "Supplied lambda must take exactly one argument");
+        explicit BoundLambda(L const &lambda) : m_lambda(lambda) {}
 
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        auto setValue(std::string const &arg) -> ParserResult override
+        {
+          return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(m_lambda, arg);
         }
-    };
+      };
 
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
+      template <typename L> struct BoundFlagLambda : BoundFlagRefBase
+      {
         L m_lambda;
 
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+        static_assert(UnaryLambdaTraits<L>::isValid,
+                      "Supplied lambda must take exactly one argument");
+        static_assert(std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value,
+                      "flags must be boolean");
 
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+        explicit BoundFlagLambda(L const &lambda) : m_lambda(lambda) {}
 
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        auto setFlag(bool flag) -> ParserResult override
+        {
+          return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(m_lambda, flag);
         }
-    };
+      };
 
-    enum class Optionality { Optional, Required };
+      enum class Optionality { Optional, Required };
 
-    struct Parser;
+      struct Parser;
 
-    class ParserBase {
-    public:
+      class ParserBase
+      {
+      public:
         virtual ~ParserBase() = default;
         virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto parse(std::string const &exeName, TokenStream const &tokens) const
+            -> InternalParseResult = 0;
         virtual auto cardinality() const -> size_t { return 1; }
 
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
+        auto parse(Args const &args) const -> InternalParseResult
+        {
+          return parse(args.exeName(), TokenStream(args));
         }
-    };
+      };
 
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
+      template <typename DerivedT> class ComposableParserImpl : public ParserBase
+      {
+      public:
+        template <typename T> auto operator|(T const &other) const -> Parser;
 
-		template<typename T>
-        auto operator+( T const &other ) const -> Parser;
-    };
+        template <typename T> auto operator+(T const &other) const -> Parser;
+      };
 
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
+      // Common code and state for Args and Opts
+      template <typename DerivedT> class ParserRefImpl : public ComposableParserImpl<DerivedT>
+      {
+      protected:
+        Optionality               m_optionality = Optionality::Optional;
         std::shared_ptr<BoundRef> m_ref;
-        std::string m_hint;
-        std::string m_description;
+        std::string               m_hint;
+        std::string               m_description;
 
-        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+        explicit ParserRefImpl(std::shared_ptr<BoundRef> const &ref) : m_ref(ref) {}
 
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
+      public:
+        template <typename T>
+        ParserRefImpl(T &ref, std::string const &hint)
+            : m_ref(std::make_shared<BoundValueRef<T>>(ref)), m_hint(hint)
+        {
+        }
+
+        template <typename LambdaT>
+        ParserRefImpl(LambdaT const &ref, std::string const &hint)
+            : m_ref(std::make_shared<BoundLambda<LambdaT>>(ref)), m_hint(hint)
+        {
         }
 
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
+        auto operator()(std::string const &description) -> DerivedT &
+        {
+          m_description = description;
+          return static_cast<DerivedT &>(*this);
+        }
+
+        auto optional() -> DerivedT &
+        {
+          m_optionality = Optionality::Optional;
+          return static_cast<DerivedT &>(*this);
         };
 
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
+        auto required() -> DerivedT &
+        {
+          m_optionality = Optionality::Required;
+          return static_cast<DerivedT &>(*this);
         };
 
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
+        auto isOptional() const -> bool { return m_optionality == Optionality::Optional; }
 
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
+        auto cardinality() const -> size_t override
+        {
+          if (m_ref->isContainer())
+            return 0;
+          else
+            return 1;
         }
 
         auto hint() const -> std::string { return m_hint; }
-    };
+      };
 
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
+      class ExeName : public ComposableParserImpl<ExeName>
+      {
+        std::shared_ptr<std::string>       m_name;
         std::shared_ptr<BoundValueRefBase> m_ref;
 
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        template <typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase>
+        {
+          return std::make_shared<BoundLambda<LambdaT>>(lambda);
         }
 
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+      public:
+        ExeName() : m_name(std::make_shared<std::string>("<executable>")) {}
 
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        explicit ExeName(std::string &ref) : ExeName()
+        {
+          m_ref = std::make_shared<BoundValueRef<std::string>>(ref);
         }
 
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        template <typename LambdaT> explicit ExeName(LambdaT const &lambda) : ExeName()
+        {
+          m_ref = std::make_shared<BoundLambda<LambdaT>>(lambda);
         }
 
         // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        auto parse(std::string const &, TokenStream const &tokens) const
+            -> InternalParseResult override
+        {
+          return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, tokens));
         }
 
         auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
+        auto set(std::string const &newName) -> ParserResult
+        {
 
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
+          auto lastSlash = newName.find_last_of("\\/");
+          auto filename =
+              (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);
 
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
+          *m_name = filename;
+          if (m_ref)
+            return m_ref->setValue(filename);
+          else
+            return ParserResult::ok(ParseResultType::Matched);
         }
-    };
+      };
 
-    class Arg : public ParserRefImpl<Arg> {
-    public:
+      class Arg : public ParserRefImpl<Arg>
+      {
+      public:
         using ParserRefImpl::ParserRefImpl;
 
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
+        auto parse(std::string const &, TokenStream const &tokens) const
+            -> InternalParseResult override
+        {
+          auto validationResult = validate();
+          if (!validationResult)
+            return InternalParseResult(validationResult);
 
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+          auto        remainingTokens = tokens;
+          auto const &token           = *remainingTokens;
+          if (token.type != TokenType::Argument)
+            return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, remainingTokens));
 
-            assert( !m_ref->isFlag() );
-            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+          assert(!m_ref->isFlag());
+          auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get());
 
-            auto result = valueRef->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+          auto result = valueRef->setValue(remainingTokens->token);
+          if (!result)
+            return InternalParseResult(result);
+          else
+            return InternalParseResult::ok(ParseState(ParseResultType::Matched, ++remainingTokens));
         }
-    };
+      };
 
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+      inline auto normaliseOpt(std::string const &optName) -> std::string
+      {
 #ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
+        if (optName[0] == '/')
+          return "-" + optName.substr(1);
         else
 #endif
-            return optName;
-    }
+          return optName;
+      }
 
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
+      class Opt : public ParserRefImpl<Opt>
+      {
+      protected:
         std::vector<std::string> m_optNames;
 
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+      public:
+        template <typename LambdaT>
+        explicit Opt(LambdaT const &ref)
+            : ParserRefImpl(std::make_shared<BoundFlagLambda<LambdaT>>(ref))
+        {
+        }
 
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+        explicit Opt(bool &ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}
 
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+        template <typename LambdaT>
+        Opt(LambdaT const &ref, std::string const &hint) : ParserRefImpl(ref, hint)
+        {
+        }
 
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+        template <typename T> Opt(T &ref, std::string const &hint) : ParserRefImpl(ref, hint) {}
 
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
+        auto operator[](std::string const &optName) -> Opt &
+        {
+          m_optNames.push_back(optName);
+          return *this;
         }
 
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
+        auto getHelpColumns() const -> std::vector<HelpColumns>
+        {
+          std::ostringstream oss;
+          bool               first = true;
+          for (auto const &opt : m_optNames) {
+            if (first)
+              first = false;
+            else
+              oss << ", ";
+            oss << opt;
+          }
+          if (!m_hint.empty())
+            oss << " <" << m_hint << ">";
+          return {{oss.str(), m_description}};
         }
 
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
+        auto isMatch(std::string const &optToken) const -> bool
+        {
+          auto normalisedToken = normaliseOpt(optToken);
+          for (auto const &name : m_optNames) {
+            if (normaliseOpt(name) == normalisedToken)
+              return true;
+          }
+          return false;
         }
 
         using ParserBase::parse;
 
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
-                        auto result = flagRef->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = valueRef->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
+        auto parse(std::string const &, TokenStream const &tokens) const
+            -> InternalParseResult override
+        {
+          auto validationResult = validate();
+          if (!validationResult)
+            return InternalParseResult(validationResult);
+
+          auto remainingTokens = tokens;
+          if (remainingTokens && remainingTokens->type == TokenType::Option) {
+            auto const &token = *remainingTokens;
+            if (isMatch(token.token)) {
+              if (m_ref->isFlag()) {
+                auto flagRef = static_cast<detail::BoundFlagRefBase *>(m_ref.get());
+                auto result  = flagRef->setFlag(true);
+                if (!result)
+                  return InternalParseResult(result);
+                if (result.value() == ParseResultType::ShortCircuitAll)
+                  return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
+              }
+              else {
+                auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get());
+                ++remainingTokens;
+                if (!remainingTokens)
+                  return InternalParseResult::runtimeError("Expected argument following " +
+                                                           token.token);
+                auto const &argToken = *remainingTokens;
+                if (argToken.type != TokenType::Argument)
+                  return InternalParseResult::runtimeError("Expected argument following " +
+                                                           token.token);
+                auto result = valueRef->setValue(argToken.token);
+                if (!result)
+                  return InternalParseResult(result);
+                if (result.value() == ParseResultType::ShortCircuitAll)
+                  return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
+              }
+              return InternalParseResult::ok(
+                  ParseState(ParseResultType::Matched, ++remainingTokens));
             }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+          }
+          return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, remainingTokens));
         }
 
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
+        auto validate() const -> Result override
+        {
+          if (m_optNames.empty())
+            return Result::logicError("No options supplied to Opt");
+          for (auto const &name : m_optNames) {
+            if (name.empty())
+              return Result::logicError("Option name cannot be empty");
 #ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
+            if (name[0] != '-' && name[0] != '/')
+              return Result::logicError("Option name must begin with '-' or '/'");
 #else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
+            if (name[0] != '-')
+              return Result::logicError("Option name must begin with '-'");
 #endif
-            }
-            return ParserRefImpl::validate();
+          }
+          return ParserRefImpl::validate();
         }
-    };
+      };
 
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
+      struct Help : Opt
+      {
+        Help(bool &showHelpFlag)
+            : Opt([&](bool flag) {
                 showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
+                return ParserResult::ok(ParseResultType::ShortCircuitAll);
+              })
         {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
+          static_cast<Opt &> (*this)("display usage information")["-?"]["-h"]["--help"].optional();
         }
-    };
+      };
 
-    struct Parser : ParserBase {
+      struct Parser : ParserBase
+      {
 
-        mutable ExeName m_exeName;
+        mutable ExeName  m_exeName;
         std::vector<Opt> m_options;
         std::vector<Arg> m_args;
 
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
+        auto operator|=(ExeName const &exeName) -> Parser &
+        {
+          m_exeName = exeName;
+          return *this;
         }
 
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
+        auto operator|=(Arg const &arg) -> Parser &
+        {
+          m_args.push_back(arg);
+          return *this;
         }
 
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
+        auto operator|=(Opt const &opt) -> Parser &
+        {
+          m_options.push_back(opt);
+          return *this;
         }
 
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
+        auto operator|=(Parser const &other) -> Parser &
+        {
+          m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+          m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+          return *this;
         }
 
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
+        template <typename T> auto operator|(T const &other) const -> Parser
+        {
+          return Parser(*this) |= other;
         }
 
         // Forward deprecated interface with '+' instead of '|'
-        template<typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
-        template<typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
+        template <typename T> auto operator+=(T const &other) -> Parser &
+        {
+          return operator|=(other);
+        }
+        template <typename T> auto operator+(T const &other) const -> Parser
+        {
+          return operator|(other);
         }
 
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
+        auto getHelpColumns() const -> std::vector<HelpColumns>
+        {
+          std::vector<HelpColumns> cols;
+          for (auto const &o : m_options) {
+            auto childCols = o.getHelpColumns();
+            cols.insert(cols.end(), childCols.begin(), childCols.end());
+          }
+          return cols;
+        }
+
+        void writeToStream(std::ostream &os) const
+        {
+          if (!m_exeName.name().empty()) {
+            os << "usage:\n"
+               << "  " << m_exeName.name() << " ";
+            bool required = true, first = true;
+            for (auto const &arg : m_args) {
+              if (first)
+                first = false;
+              else
+                os << " ";
+              if (arg.isOptional() && required) {
+                os << "[";
+                required = false;
+              }
+              os << "<" << arg.hint() << ">";
+              if (arg.cardinality() == 0)
+                os << " ... ";
             }
+            if (!required)
+              os << "]";
+            if (!m_options.empty())
+              os << " options";
+            os << "\n\nwhere options are:" << std::endl;
+          }
 
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+          auto   rows         = getHelpColumns();
+          size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+          size_t optWidth     = 0;
+          for (auto const &cols : rows)
+            optWidth = (std::max)(optWidth, cols.left.size() + 2);
 
-            optWidth = (std::min)(optWidth, consoleWidth/2);
+          optWidth = (std::min)(optWidth, consoleWidth / 2);
 
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
+          for (auto const &cols : rows) {
+            auto row = TextFlow::Column(cols.left).width(optWidth).indent(2) + TextFlow::Spacer(4) +
+                       TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth);
+            os << row << std::endl;
+          }
         }
 
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
+        friend auto operator<<(std::ostream &os, Parser const &parser) -> std::ostream &
+        {
+          parser.writeToStream(os);
+          return os;
         }
 
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
+        auto validate() const -> Result override
+        {
+          for (auto const &opt : m_options) {
+            auto result = opt.validate();
+            if (!result)
+              return result;
+          }
+          for (auto const &arg : m_args) {
+            auto result = arg.validate();
+            if (!result)
+              return result;
+          }
+          return Result::ok();
         }
 
         using ParserBase::parse;
 
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
+        auto parse(std::string const &exeName, TokenStream const &tokens) const
+            -> InternalParseResult override
+        {
 
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
+          struct ParserInfo
+          {
+            ParserBase const *parser = nullptr;
+            size_t            count  = 0;
+          };
+          const size_t totalParsers = m_options.size() + m_args.size();
+          assert(totalParsers < 512);
+          // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+          ParserInfo parseInfos[512];
+
+          {
+            size_t i = 0;
+            for (auto const &opt : m_options)
+              parseInfos[i++].parser = &opt;
+            for (auto const &arg : m_args)
+              parseInfos[i++].parser = &arg;
+          }
+
+          m_exeName.set(exeName);
+
+          auto result = InternalParseResult::ok(ParseState(ParseResultType::NoMatch, tokens));
+          while (result.value().remainingTokens()) {
+            bool tokenParsed = false;
+
+            for (size_t i = 0; i < totalParsers; ++i) {
+              auto &parseInfo = parseInfos[i];
+              if (parseInfo.parser->cardinality() == 0 ||
+                  parseInfo.count < parseInfo.parser->cardinality()) {
+                result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                if (!result)
+                  return result;
+                if (result.value().type() != ParseResultType::NoMatch) {
+                  tokenParsed = true;
+                  ++parseInfo.count;
+                  break;
                 }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+              }
             }
-            // !TBD Check missing required options
-            return result;
+
+            if (result.value().type() == ParseResultType::ShortCircuitAll)
+              return result;
+            if (!tokenParsed)
+              return InternalParseResult::runtimeError("Unrecognised token: " +
+                                                       result.value().remainingTokens()->token);
+          }
+          // !TBD Check missing required options
+          return result;
         }
-    };
+      };
 
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
+      template <typename DerivedT>
+      template <typename T>
+      auto ComposableParserImpl<DerivedT>::operator|(T const &other) const -> Parser
+      {
+        return Parser() | static_cast<DerivedT const &>(*this) | other;
+      }
+    } // namespace detail
 
-// A Combined parser
-using detail::Parser;
+    // A Combined parser
+    using detail::Parser;
 
-// A parser for options
-using detail::Opt;
+    // A parser for options
+    using detail::Opt;
 
-// A parser for arguments
-using detail::Arg;
+    // A parser for arguments
+    using detail::Arg;
 
-// Wrapper for argc, argv from main()
-using detail::Args;
+    // Wrapper for argc, argv from main()
+    using detail::Args;
 
-// Specifies the name of the executable
-using detail::ExeName;
+    // Specifies the name of the executable
+    using detail::ExeName;
 
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
+    // Convenience wrapper for option parser that specifies the help option
+    using detail::Help;
 
-// enum of result types from a parse
-using detail::ParseResultType;
+    // enum of result types from a parse
+    using detail::ParseResultType;
 
-// Result type for parser operation
-using detail::ParserResult;
+    // Result type for parser operation
+    using detail::ParserResult;
 
-}} // namespace Catch::clara
+  } // namespace clara
+} // namespace Catch
 
 // end clara.hpp
 #ifdef __clang__
@@ -9372,211 +10347,178 @@ using detail::ParserResult;
 // end catch_clara.h
 namespace Catch {
 
-    clara::Parser makeCommandLineParser( ConfigData& config );
+  clara::Parser makeCommandLineParser(ConfigData &config);
 
 } // end namespace Catch
 
 // end catch_commandline.h
-#include <fstream>
 #include <ctime>
+#include <fstream>
 
 namespace Catch {
 
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
+  clara::Parser makeCommandLineParser(ConfigData &config)
+  {
 
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
+    using namespace clara;
 
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
+    auto const setWarning = [&](std::string const &warning) {
+      auto warningSet = [&]() {
+        if (warning == "NoAssertions")
+          return WarnAbout::NoAssertions;
 
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line + ',' );
-                    }
-                }
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        if (warning == "NoTests")
+          return WarnAbout::NoTests;
 
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
+        return WarnAbout::Nothing;
+      }();
 
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
+      if (warningSet == WarnAbout::Nothing)
+        return ParserResult::runtimeError("Unrecognised warning: '" + warning + "'");
+      config.warnings = static_cast<WarnAbout::What>(config.warnings | warningSet);
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const loadTestNamesFromFile = [&](std::string const &filename) {
+      std::ifstream f(filename.c_str());
+      if (!f.is_open())
+        return ParserResult::runtimeError("Unable to load input file: '" + filename + "'");
+
+      std::string line;
+      while (std::getline(f, line)) {
+        line = trim(line);
+        if (!line.empty() && !startsWith(line, '#')) {
+          if (!startsWith(line, '"'))
+            line = '"' + line + '"';
+          config.testsOrTags.push_back(line);
+          config.testsOrTags.push_back(",");
+        }
+      }
+      // Remove comma in the end
+      if (!config.testsOrTags.empty())
+        config.testsOrTags.erase(config.testsOrTags.end() - 1);
+
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const setTestOrder = [&](std::string const &order) {
+      if (startsWith("declared", order))
+        config.runOrder = RunTests::InDeclarationOrder;
+      else if (startsWith("lexical", order))
+        config.runOrder = RunTests::InLexicographicalOrder;
+      else if (startsWith("random", order))
+        config.runOrder = RunTests::InRandomOrder;
+      else
+        return clara::ParserResult::runtimeError("Unrecognised ordering: '" + order + "'");
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const setRngSeed = [&](std::string const &seed) {
+      if (seed != "time")
+        return clara::detail::convertInto(seed, config.rngSeed);
+      config.rngSeed = static_cast<unsigned int>(std::time(nullptr));
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const setColourUsage = [&](std::string const &useColour) {
+      auto mode = toLower(useColour);
+
+      if (mode == "yes")
+        config.useColour = UseColour::Yes;
+      else if (mode == "no")
+        config.useColour = UseColour::No;
+      else if (mode == "auto")
+        config.useColour = UseColour::Auto;
+      else
+        return ParserResult::runtimeError("colour mode must be one of: auto, yes or no. '" +
+                                          useColour + "' not recognised");
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const setWaitForKeypress = [&](std::string const &keypress) {
+      auto keypressLc = toLower(keypress);
+      if (keypressLc == "start")
+        config.waitForKeypress = WaitForKeypress::BeforeStart;
+      else if (keypressLc == "exit")
+        config.waitForKeypress = WaitForKeypress::BeforeExit;
+      else if (keypressLc == "both")
+        config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+      else
+        return ParserResult::runtimeError(
+            "keypress argument must be one of: start, exit or both. '" + keypress +
+            "' not recognised");
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const setVerbosity = [&](std::string const &verbosity) {
+      auto lcVerbosity = toLower(verbosity);
+      if (lcVerbosity == "quiet")
+        config.verbosity = Verbosity::Quiet;
+      else if (lcVerbosity == "normal")
+        config.verbosity = Verbosity::Normal;
+      else if (lcVerbosity == "high")
+        config.verbosity = Verbosity::High;
+      else
+        return ParserResult::runtimeError("Unrecognised verbosity, '" + verbosity + "'");
+      return ParserResult::ok(ParseResultType::Matched);
+    };
+    auto const setReporter = [&](std::string const &reporter) {
+      IReporterRegistry::FactoryMap const &factories =
+          getRegistryHub().getReporterRegistry().getFactories();
+
+      auto lcReporter = toLower(reporter);
+      auto result     = factories.find(lcReporter);
+
+      if (factories.end() != result)
+        config.reporterName = lcReporter;
+      else
+        return ParserResult::runtimeError("Unrecognized reporter, '" + reporter +
+                                          "'. Check available with --list-reporters");
+      return ParserResult::ok(ParseResultType::Matched);
+    };
 
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-			| Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
+    auto cli =
+        ExeName(config.processName) | Help(config.showHelp) |
+        Opt(config.listTests)["-l"]["--list-tests"]("list all/matching test cases") |
+        Opt(config.listTags)["-t"]["--list-tags"]("list all/matching tags") |
+        Opt(config.showSuccessfulTests)["-s"]["--success"]("include successful tests in output") |
+        Opt(config.shouldDebugBreak)["-b"]["--break"]("break into debugger on failure") |
+        Opt(config.noThrow)["-e"]["--nothrow"]("skip exception tests") |
+        Opt(config.showInvisibles)["-i"]["--invisibles"]("show invisibles (tabs, newlines)") |
+        Opt(config.outputFilename, "filename")["-o"]["--out"]("output filename") |
+        Opt(setReporter, "name")["-r"]["--reporter"]("reporter to use (defaults to console)") |
+        Opt(config.name, "name")["-n"]["--name"]("suite name") |
+        Opt([&](bool) { config.abortAfter = 1; })["-a"]["--abort"]("abort at first failure") |
+        Opt([&](int x) { config.abortAfter = x; },
+            "no. failures")["-x"]["--abortx"]("abort after x failures") |
+        Opt(setWarning, "warning name")["-w"]["--warn"]("enable warnings") |
+        Opt(
+            [&](bool flag) {
+              config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never;
+            },
+            "yes|no")["-d"]["--durations"]("show test durations") |
+        Opt(loadTestNamesFromFile,
+            "filename")["-f"]["--input-file"]("load test names to run from a file") |
+        Opt(config.filenamesAsTags)["-#"]["--filenames-as-tags"]("adds a tag for the filename") |
+        Opt(config.sectionsToRun, "section name")["-c"]["--section"]("specify section to run") |
+        Opt(setVerbosity, "quiet|normal|high")["-v"]["--verbosity"]("set output verbosity") |
+        Opt(config.listTestNamesOnly)["--list-test-names-only"](
+            "list all/matching test cases names only") |
+        Opt(config.listReporters)["--list-reporters"]("list all reporters") |
+        Opt(setTestOrder, "decl|lex|rand")["--order"]("test case order (defaults to decl)") |
+        Opt(setRngSeed, "'time'|number")["--rng-seed"]("set a specific seed for random numbers") |
+        Opt(setColourUsage, "yes|no")["--use-colour"]("should output be colourised") |
+        Opt(config.libIdentify)["--libidentify"](
+            "report name and version according to libidentify standard") |
+        Opt(setWaitForKeypress,
+            "start|exit|both")["--wait-for-keypress"]("waits for a keypress before exiting") |
+        Opt(config.benchmarkSamples,
+            "samples")["--benchmark-samples"]("number of samples to collect (default: 100)") |
+        Opt(config.benchmarkResamples, "resamples")["--benchmark-resamples"](
+            "number of resamples for the bootstrap (default: 100000)") |
+        Opt(config.benchmarkConfidenceInterval,
+            "confidence interval")["--benchmark-confidence-interval"](
+            "confidence interval for the bootstrap (between 0 and 1, default: 0.95)") |
+        Opt(config.benchmarkNoAnalysis)["--benchmark-no-analysis"](
+            "perform only measurements; do not perform any analysis") |
+        Arg(config.testsOrTags, "test name|pattern|tags")("which test or tests to use");
+
+    return cli;
+  }
 
 } // end namespace Catch
 // end catch_commandline.cpp
@@ -9587,298 +10529,321 @@ namespace Catch {
 
 namespace Catch {
 
-    bool SourceLineInfo::empty() const noexcept {
-        return file[0] == '\0';
-    }
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
+  bool SourceLineInfo::operator==(SourceLineInfo const &other) const noexcept
+  {
+    return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+  }
+  bool SourceLineInfo::operator<(SourceLineInfo const &other) const noexcept
+  {
+    // We can assume that the same file will usually have the same pointer.
+    // Thus, if the pointers are the same, there is no point in calling the strcmp
+    return line < other.line ||
+           (line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+  }
 
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+  std::ostream &operator<<(std::ostream &os, SourceLineInfo const &info)
+  {
 #ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
+    os << info.file << '(' << info.line << ')';
 #else
-        os << info.file << ':' << info.line;
+    os << info.file << ':' << info.line;
 #endif
-        return os;
-    }
+    return os;
+  }
 
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
+  std::string StreamEndStop::operator+() const { return std::string(); }
 
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
+  NonCopyable::NonCopyable()  = default;
+  NonCopyable::~NonCopyable() = default;
 
-}
+} // namespace Catch
 // end catch_common.cpp
 // start catch_config.cpp
 
 namespace Catch {
 
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for( auto const& testOrTags : data.testsOrTags )
-                parser.parse( testOrTags );
-        }
-        m_testSpec = parser.testSpec();
+  Config::Config(ConfigData const &data) : m_data(data), m_stream(openStream())
+  {
+    // We need to trim filter specs to avoid trouble with superfluous
+    // whitespace (esp. important for bdd macros, as those are manually
+    // aligned with whitespace).
+
+    for (auto &elem : m_data.testsOrTags) {
+      elem = trim(elem);
+    }
+    for (auto &elem : m_data.sectionsToRun) {
+      elem = trim(elem);
     }
 
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
+    TestSpecParser parser(ITagAliasRegistry::get());
+    if (!m_data.testsOrTags.empty()) {
+      m_hasTestFilters = true;
+      for (auto const &testOrTags : m_data.testsOrTags) {
+        parser.parse(testOrTags);
+      }
     }
+    m_testSpec = parser.testSpec();
+  }
 
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
+  std::string const &Config::getFilename() const { return m_data.outputFilename; }
 
-    std::string Config::getProcessName() const { return m_data.processName; }
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
+  bool Config::listTests() const { return m_data.listTests; }
+  bool Config::listTestNamesOnly() const { return m_data.listTestNamesOnly; }
+  bool Config::listTags() const { return m_data.listTags; }
+  bool Config::listReporters() const { return m_data.listReporters; }
 
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+  std::string        Config::getProcessName() const { return m_data.processName; }
+  std::string const &Config::getReporterName() const { return m_data.reporterName; }
 
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+  std::vector<std::string> const &Config::getTestsOrTags() const { return m_data.testsOrTags; }
+  std::vector<std::string> const &Config::getSectionsToRun() const { return m_data.sectionsToRun; }
 
-    bool Config::showHelp() const { return m_data.showHelp; }
+  TestSpec const &Config::testSpec() const { return m_testSpec; }
+  bool            Config::hasTestFilters() const { return m_hasTestFilters; }
 
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
-    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::benchmarkNoAnalysis() const           { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const               { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const    { return m_data.benchmarkResamples; }
-
-    IStream const* Config::openStream() {
-        return Catch::makeStream(m_data.outputFilename);
-    }
+  bool Config::showHelp() const { return m_data.showHelp; }
+
+  // IConfig interface
+  bool          Config::allowThrows() const { return !m_data.noThrow; }
+  std::ostream &Config::stream() const { return m_stream->stream(); }
+  std::string   Config::name() const
+  {
+    return m_data.name.empty() ? m_data.processName : m_data.name;
+  }
+  bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
+  bool Config::warnAboutMissingAssertions() const
+  {
+    return !!(m_data.warnings & WarnAbout::NoAssertions);
+  }
+  bool Config::warnAboutNoTests() const { return !!(m_data.warnings & WarnAbout::NoTests); }
+  ShowDurations::OrNot  Config::showDurations() const { return m_data.showDurations; }
+  RunTests::InWhatOrder Config::runOrder() const { return m_data.runOrder; }
+  unsigned int          Config::rngSeed() const { return m_data.rngSeed; }
+  UseColour::YesOrNo    Config::useColour() const { return m_data.useColour; }
+  bool                  Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }
+  int                   Config::abortAfter() const { return m_data.abortAfter; }
+  bool                  Config::showInvisibles() const { return m_data.showInvisibles; }
+  Verbosity             Config::verbosity() const { return m_data.verbosity; }
+
+  bool   Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }
+  int    Config::benchmarkSamples() const { return m_data.benchmarkSamples; }
+  double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
+  unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
+
+  IStream const *Config::openStream() { return Catch::makeStream(m_data.outputFilename); }
 
 } // end namespace Catch
 // end catch_config.cpp
 // start catch_console_colour.cpp
 
 #if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
 #endif
 
 // start catch_errno_guard.h
 
 namespace Catch {
 
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
+  class ErrnoGuard
+  {
+  public:
+    ErrnoGuard();
+    ~ErrnoGuard();
 
-}
+  private:
+    int m_oldErrno;
+  };
+
+} // namespace Catch
 
 // end catch_errno_guard.h
 #include <sstream>
 
 namespace Catch {
-    namespace {
+  namespace {
 
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
+    struct IColourImpl
+    {
+      virtual ~IColourImpl()                     = default;
+      virtual void use(Colour::Code _colourCode) = 0;
+    };
 
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
+    struct NoColourImpl : IColourImpl
+    {
+      void use(Colour::Code) {}
 
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
+      static IColourImpl *instance()
+      {
+        static NoColourImpl s_instance;
+        return &s_instance;
+      }
+    };
 
-    } // anon namespace
+  } // namespace
 } // namespace Catch
 
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
+#if !defined(CATCH_CONFIG_COLOUR_NONE) && !defined(CATCH_CONFIG_COLOUR_WINDOWS) &&                 \
+    !defined(CATCH_CONFIG_COLOUR_ANSI)
+#ifdef CATCH_PLATFORM_WINDOWS
+#define CATCH_CONFIG_COLOUR_WINDOWS
+#else
+#define CATCH_CONFIG_COLOUR_ANSI
+#endif
 #endif
 
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+#if defined(CATCH_CONFIG_COLOUR_WINDOWS) /////////////////////////////////////////
 
 namespace Catch {
-namespace {
+  namespace {
 
-    class Win32ColourImpl : public IColourImpl {
+    class Win32ColourImpl : public IColourImpl
+    {
     public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
+      Win32ColourImpl() : stdoutHandle(GetStdHandle(STD_OUTPUT_HANDLE))
+      {
+        CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+        GetConsoleScreenBufferInfo(stdoutHandle, &csbiInfo);
+        originalForegroundAttributes =
+            csbiInfo.wAttributes &
+            ~(BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY);
+        originalBackgroundAttributes =
+            csbiInfo.wAttributes &
+            ~(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
+      }
+
+      void use(Colour::Code _colourCode) override
+      {
+        switch (_colourCode) {
+        case Colour::None: return setTextAttribute(originalForegroundAttributes);
+        case Colour::White:
+          return setTextAttribute(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE);
+        case Colour::Red: return setTextAttribute(FOREGROUND_RED);
+        case Colour::Green: return setTextAttribute(FOREGROUND_GREEN);
+        case Colour::Blue: return setTextAttribute(FOREGROUND_BLUE);
+        case Colour::Cyan: return setTextAttribute(FOREGROUND_BLUE | FOREGROUND_GREEN);
+        case Colour::Yellow: return setTextAttribute(FOREGROUND_RED | FOREGROUND_GREEN);
+        case Colour::Grey: return setTextAttribute(0);
+
+        case Colour::LightGrey: return setTextAttribute(FOREGROUND_INTENSITY);
+        case Colour::BrightRed: return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_RED);
+        case Colour::BrightGreen: return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_GREEN);
+        case Colour::BrightWhite:
+          return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED |
+                                  FOREGROUND_BLUE);
+        case Colour::BrightYellow:
+          return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
+
+        case Colour::Bright: CATCH_INTERNAL_ERROR("not a colour");
+
+        default: CATCH_ERROR("Unknown colour requested");
+        }
+      }
 
     private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
+      void setTextAttribute(WORD _textAttribute)
+      {
+        SetConsoleTextAttribute(stdoutHandle, _textAttribute | originalBackgroundAttributes);
+      }
+      HANDLE stdoutHandle;
+      WORD   originalForegroundAttributes;
+      WORD   originalBackgroundAttributes;
     };
 
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
+    IColourImpl *platformColourInstance()
+    {
+      static Win32ColourImpl s_instance;
 
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
+      IConfigPtr         config     = getCurrentContext().getConfig();
+      UseColour::YesOrNo colourMode = config ? config->useColour() : UseColour::Auto;
+      if (colourMode == UseColour::Auto)
+        colourMode = UseColour::Yes;
+      return colourMode == UseColour::Yes ? &s_instance : NoColourImpl::instance();
     }
 
-} // end anon namespace
+  } // namespace
 } // end namespace Catch
 
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+#elif defined(CATCH_CONFIG_COLOUR_ANSI) //////////////////////////////////////
 
 #include <unistd.h>
 
 namespace Catch {
-namespace {
+  namespace {
 
     // use POSIX/ ANSI console terminal codes
     // Thanks to Adam Strzelecki for original contribution
     // (http://github.com/nanoant)
     // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
+    class PosixColourImpl : public IColourImpl
+    {
     public:
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
+      void use(Colour::Code _colourCode) override
+      {
+        switch (_colourCode) {
+        case Colour::None:
+        case Colour::White: return setColour("[0m");
+        case Colour::Red: return setColour("[0;31m");
+        case Colour::Green: return setColour("[0;32m");
+        case Colour::Blue: return setColour("[0;34m");
+        case Colour::Cyan: return setColour("[0;36m");
+        case Colour::Yellow: return setColour("[0;33m");
+        case Colour::Grey: return setColour("[1;30m");
+
+        case Colour::LightGrey: return setColour("[0;37m");
+        case Colour::BrightRed: return setColour("[1;31m");
+        case Colour::BrightGreen: return setColour("[1;32m");
+        case Colour::BrightWhite: return setColour("[1;37m");
+        case Colour::BrightYellow: return setColour("[1;33m");
+
+        case Colour::Bright: CATCH_INTERNAL_ERROR("not a colour");
+        default: CATCH_INTERNAL_ERROR("Unknown colour requested");
+        }
+      }
+      static IColourImpl *instance()
+      {
+        static PosixColourImpl s_instance;
+        return &s_instance;
+      }
 
     private:
-        void setColour( const char* _escapeCode ) {
-            getCurrentContext().getConfig()->stream()
-                << '\033' << _escapeCode;
-        }
+      void setColour(const char *_escapeCode)
+      {
+        getCurrentContext().getConfig()->stream() << '\033' << _escapeCode;
+      }
     };
 
-    bool useColourOnPlatform() {
-        return
+    bool useColourOnPlatform()
+    {
+      return
 #ifdef CATCH_PLATFORM_MAC
-            !isDebuggerActive() &&
+          !isDebuggerActive() &&
 #endif
 #if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
-            isatty(STDOUT_FILENO)
+          isatty(STDOUT_FILENO)
 #else
-            false
+          false
 #endif
-            ;
+              ;
     }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
+    IColourImpl *platformColourInstance()
+    {
+      ErrnoGuard         guard;
+      IConfigPtr         config     = getCurrentContext().getConfig();
+      UseColour::YesOrNo colourMode = config ? config->useColour() : UseColour::Auto;
+      if (colourMode == UseColour::Auto)
+        colourMode = useColourOnPlatform() ? UseColour::Yes : UseColour::No;
+      return colourMode == UseColour::Yes ? PosixColourImpl::instance() : NoColourImpl::instance();
+    }
+
+  } // namespace
 } // end namespace Catch
 
-#else  // not Windows or ANSI ///////////////////////////////////////////////
+#else // not Windows or ANSI ///////////////////////////////////////////////
 
 namespace Catch {
 
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+  static IColourImpl *platformColourInstance() { return NoColourImpl::instance(); }
 
 } // end namespace Catch
 
@@ -9886,38 +10851,43 @@ namespace Catch {
 
 namespace Catch {
 
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved  = true;
-        return *this;
-    }
+  Colour::Colour(Code _colourCode) { use(_colourCode); }
+  Colour::Colour(Colour &&rhs) noexcept
+  {
+    m_moved     = rhs.m_moved;
+    rhs.m_moved = true;
+  }
+  Colour &Colour::operator=(Colour &&rhs) noexcept
+  {
+    m_moved     = rhs.m_moved;
+    rhs.m_moved = true;
+    return *this;
+  }
 
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
+  Colour::~Colour()
+  {
+    if (!m_moved)
+      use(None);
+  }
 
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        // Strictly speaking, this cannot possibly happen.
-        // However, under some conditions it does happen (see #1626),
-        // and this change is small enough that we can let practicality
-        // triumph over purity in this case.
-        if (impl != NULL) {
-            impl->use( _colourCode );
-        }
+  void Colour::use(Code _colourCode)
+  {
+    static IColourImpl *impl = platformColourInstance();
+    // Strictly speaking, this cannot possibly happen.
+    // However, under some conditions it does happen (see #1626),
+    // and this change is small enough that we can let practicality
+    // triumph over purity in this case.
+    if (impl != NULL) {
+      impl->use(_colourCode);
     }
+  }
 
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
+  std::ostream &operator<<(std::ostream &os, Colour const &) { return os; }
 
 } // end namespace Catch
 
 #if defined(__clang__)
-#    pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #endif
 
 // end catch_console_colour.cpp
@@ -9925,56 +10895,53 @@ namespace Catch {
 
 namespace Catch {
 
-    class Context : public IMutableContext, NonCopyable {
+  class Context : public IMutableContext, NonCopyable
+  {
 
-    public: // IContext
-        IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        IRunner* getRunner() override {
-            return m_runner;
-        }
+  public: // IContext
+    IResultCapture *getResultCapture() override { return m_resultCapture; }
+    IRunner *       getRunner() override { return m_runner; }
 
-        IConfigPtr const& getConfig() const override {
-            return m_config;
-        }
+    IConfigPtr const &getConfig() const override { return m_config; }
 
-        ~Context() override;
+    ~Context() override;
 
-    public: // IMutableContext
-        void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
+  public: // IMutableContext
+    void setResultCapture(IResultCapture *resultCapture) override
+    {
+      m_resultCapture = resultCapture;
+    }
+    void setRunner(IRunner *runner) override { m_runner = runner; }
+    void setConfig(IConfigPtr const &config) override { m_config = config; }
 
-        friend IMutableContext& getCurrentMutableContext();
+    friend IMutableContext &getCurrentMutableContext();
 
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
+  private:
+    IConfigPtr      m_config;
+    IRunner *       m_runner        = nullptr;
+    IResultCapture *m_resultCapture = nullptr;
+  };
 
-    IMutableContext *IMutableContext::currentContext = nullptr;
+  IMutableContext *IMutableContext::currentContext = nullptr;
 
-    void IMutableContext::createContext()
-    {
-        currentContext = new Context();
-    }
+  void IMutableContext::createContext() { currentContext = new Context(); }
 
-    void cleanUpContext() {
-        delete IMutableContext::currentContext;
-        IMutableContext::currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-}
+  void cleanUpContext()
+  {
+    delete IMutableContext::currentContext;
+    IMutableContext::currentContext = nullptr;
+  }
+  IContext::~IContext()               = default;
+  IMutableContext::~IMutableContext() = default;
+  Context::~Context()                 = default;
+
+  SimplePcg32 &rng()
+  {
+    static SimplePcg32 s_rng;
+    return s_rng;
+  }
+
+} // namespace Catch
 // end catch_context.cpp
 // start catch_debug_console.cpp
 
@@ -9983,35 +10950,35 @@ namespace Catch {
 #include <string>
 
 namespace Catch {
-    void writeToDebugConsole( std::string const& text );
+  void writeToDebugConsole(std::string const &text);
 }
 
 // end catch_debug_console.h
-#if defined(__ANDROID__)
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
 #include <android/log.h>
 
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_print( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
+namespace Catch {
+  void writeToDebugConsole(std::string const &text)
+  {
+    __android_log_write(ANDROID_LOG_DEBUG, "Catch", text.c_str());
+  }
+} // namespace Catch
 
 #elif defined(CATCH_PLATFORM_WINDOWS)
 
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
+namespace Catch {
+  void writeToDebugConsole(std::string const &text) { ::OutputDebugStringA(text.c_str()); }
+} // namespace Catch
 
 #else
 
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
+namespace Catch {
+  void writeToDebugConsole(std::string const &text)
+  {
+    // !TBD: Need a version for Mac/ XCode and other IDEs
+    Catch::cout() << text;
+  }
+} // namespace Catch
 
 #endif // Platform
 // end catch_debug_console.cpp
@@ -10019,241 +10986,263 @@ namespace Catch {
 
 #ifdef CATCH_PLATFORM_MAC
 
-#  include <assert.h>
-#  include <stdbool.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
+#include <assert.h>
+#include <cstddef>
+#include <ostream>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
+// These headers will only compile with AppleClang (XCode)
+// For other compilers (Clang, GCC, ... ) we need to exclude them
+#include <sys/sysctl.h>
 #endif
 
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+namespace Catch {
+#ifdef __apple_build_version__
+  // The following function is taken directly from the following technical note:
+  // https://developer.apple.com/library/archive/qa/qa1361/_index.html
 
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
+  // Returns true if the current process is being debugged (either
+  // running under the debugger or has a debugger attached post facto).
+  bool isDebuggerActive()
+  {
+    int               mib[4];
+    struct kinfo_proc info;
+    std::size_t       size;
 
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
+    // Initialize the flags so that, if sysctl fails for some bizarre
+    // reason, we get a predictable result.
 
-            info.kp_proc.p_flag = 0;
+    info.kp_proc.p_flag = 0;
 
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
+    // Initialize mib, which tells sysctl the info we want, in this case
+    // we're looking for information about a specific process ID.
 
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PID;
+    mib[3] = getpid();
 
-            // Call sysctl.
+    // Call sysctl.
 
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
+    size = sizeof(info);
+    if (sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0) {
+      Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n"
+                    << std::endl;
+      return false;
+    }
 
-            // We're being debugged if the P_TRACED flag is set.
+    // We're being debugged if the P_TRACED flag is set.
 
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
+    return ((info.kp_proc.p_flag & P_TRACED) != 0);
+  }
+#else
+  bool isDebuggerActive()
+  {
+    // We need to find another way to determine this for non-appleclang compilers on macOS
+    return false;
+  }
+#endif
+} // namespace Catch
 
 #elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
+#include <fstream>
+#include <string>
 
-            return false;
-        }
-    } // namespace Catch
+namespace Catch {
+  // The standard POSIX way of detecting a debugger is to attempt to
+  // ptrace() the process, but this needs to be done from a child and not
+  // this process itself to still allow attaching to this process later
+  // if wanted, so is rather heavy. Under Linux we have the PID of the
+  // "debugger" (which doesn't need to be gdb, of course, it could also
+  // be strace, for example) in /proc/$PID/status, so just get it from
+  // there instead.
+  bool isDebuggerActive()
+  {
+    // Libstdc++ has a bug, where std::ifstream sets errno to 0
+    // This way our users can properly assert over errno values
+    ErrnoGuard    guard;
+    std::ifstream in("/proc/self/status");
+    for (std::string line; std::getline(in, line);) {
+      static const int PREFIX_LEN = 11;
+      if (line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) {
+        // We're traced if the PID is not 0 and no other PID starts
+        // with 0 digit, so it's enough to check for just a single
+        // character.
+        return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+      }
+    }
+
+    return false;
+  }
+} // namespace Catch
 #elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+namespace Catch {
+  bool isDebuggerActive() { return IsDebuggerPresent() != 0; }
+} // namespace Catch
 #elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+namespace Catch {
+  bool isDebuggerActive() { return IsDebuggerPresent() != 0; }
+} // namespace Catch
 #else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
+namespace Catch {
+  bool isDebuggerActive() { return false; }
+} // namespace Catch
 #endif // Platform
 // end catch_debugger.cpp
 // start catch_decomposer.cpp
 
 namespace Catch {
 
-    ITransientExpression::~ITransientExpression() = default;
+  ITransientExpression::~ITransientExpression() = default;
 
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
+  void formatReconstructedExpression(std::ostream &os, std::string const &lhs, StringRef op,
+                                     std::string const &rhs)
+  {
+    if (lhs.size() + rhs.size() < 40 && lhs.find('\n') == std::string::npos &&
+        rhs.find('\n') == std::string::npos)
+      os << lhs << " " << op << " " << rhs;
+    else
+      os << lhs << "\n" << op << "\n" << rhs;
+  }
+} // namespace Catch
 // end catch_decomposer.cpp
 // start catch_enforce.cpp
 
 #include <stdexcept>
 
 namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) &&                                                    \
+    !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+  [[noreturn]] void throw_exception(std::exception const &e)
+  {
+    Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                  << "The message was: " << e.what() << '\n';
+    std::terminate();
+  }
 #endif
 
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
+  [[noreturn]] void throw_logic_error(std::string const &msg)
+  {
+    throw_exception(std::logic_error(msg));
+  }
 
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
+  [[noreturn]] void throw_domain_error(std::string const &msg)
+  {
+    throw_exception(std::domain_error(msg));
+  }
 
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
+  [[noreturn]] void throw_runtime_error(std::string const &msg)
+  {
+    throw_exception(std::runtime_error(msg));
+  }
 
-} // namespace Catch;
+} // namespace Catch
 // end catch_enforce.cpp
 // start catch_enum_values_registry.cpp
 // start catch_enum_values_registry.h
 
-#include <vector>
 #include <memory>
+#include <vector>
 
 namespace Catch {
 
-    namespace Detail {
+  namespace Detail {
 
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+    std::unique_ptr<EnumInfo> makeEnumInfo(StringRef enumName, StringRef allValueNames,
+                                           std::vector<int> const &values);
 
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+    class EnumValuesRegistry : public IMutableEnumValuesRegistry
+    {
 
-            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+      std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
 
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
-        };
+      EnumInfo const &registerEnum(StringRef enumName, StringRef allEnums,
+                                   std::vector<int> const &values) override;
+    };
 
-        std::vector<std::string> parseEnums( StringRef enums );
+    std::vector<StringRef> parseEnums(StringRef enums);
 
-    } // Detail
+  } // namespace Detail
 
-} // Catch
+} // namespace Catch
 
 // end catch_enum_values_registry.h
 
-#include <map>
 #include <cassert>
+#include <map>
 
 namespace Catch {
 
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+  IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
 
-    namespace Detail {
+  namespace Detail {
 
-        std::vector<std::string> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<std::string> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                auto identifiers = splitStringRef( enumValue, ':' );
-                parsed.push_back( Catch::trim( identifiers.back() ) );
-            }
-            return parsed;
-        }
+    namespace {
+      // Extracts the actual name part of an enum instance
+      // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+      StringRef extractInstanceName(StringRef enumInstance)
+      {
+        // Find last occurence of ":"
+        size_t name_start = enumInstance.size();
+        while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+          --name_start;
+        }
+        return enumInstance.substr(name_start, enumInstance.size() - name_start);
+      }
+    } // namespace
+
+    std::vector<StringRef> parseEnums(StringRef enums)
+    {
+      auto                   enumValues = splitStringRef(enums, ',');
+      std::vector<StringRef> parsed;
+      parsed.reserve(enumValues.size());
+      for (auto const &enumValue : enumValues) {
+        parsed.push_back(trim(extractInstanceName(enumValue)));
+      }
+      return parsed;
+    }
 
-        EnumInfo::~EnumInfo() {}
+    EnumInfo::~EnumInfo() {}
 
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}";
-        }
+    StringRef EnumInfo::lookup(int value) const
+    {
+      for (auto const &valueToName : m_values) {
+        if (valueToName.first == value)
+          return valueToName.second;
+      }
+      return "{** unexpected enum value **}"_sr;
+    }
 
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
+    std::unique_ptr<EnumInfo> makeEnumInfo(StringRef enumName, StringRef allValueNames,
+                                           std::vector<int> const &values)
+    {
+      std::unique_ptr<EnumInfo> enumInfo(new EnumInfo);
+      enumInfo->m_name = enumName;
+      enumInfo->m_values.reserve(values.size());
 
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.push_back({ value, valueNames[i++] });
+      const auto valueNames = Catch::Detail::parseEnums(allValueNames);
+      assert(valueNames.size() == values.size());
+      std::size_t i = 0;
+      for (auto value : values)
+        enumInfo->m_values.push_back({value, valueNames[i++]});
 
-            return enumInfo;
-        }
+      return enumInfo;
+    }
 
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            auto enumInfo = makeEnumInfo( enumName, allValueNames, values );
-            EnumInfo* raw = enumInfo.get();
-            m_enumInfos.push_back( std::move( enumInfo ) );
-            return *raw;
-        }
+    EnumInfo const &EnumValuesRegistry::registerEnum(StringRef enumName, StringRef allValueNames,
+                                                     std::vector<int> const &values)
+    {
+      m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+      return *m_enumInfos.back();
+    }
 
-    } // Detail
-} // Catch
+  } // namespace Detail
+} // namespace Catch
 
 // end catch_enum_values_registry.cpp
 // start catch_errno_guard.cpp
@@ -10261,31 +11250,32 @@ namespace Catch {
 #include <cerrno>
 
 namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
+  ErrnoGuard::ErrnoGuard() : m_oldErrno(errno) {}
+  ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+} // namespace Catch
 // end catch_errno_guard.cpp
 // start catch_exception_translator_registry.cpp
 
 // start catch_exception_translator_registry.h
 
-#include <vector>
-#include <string>
 #include <memory>
+#include <string>
+#include <vector>
 
 namespace Catch {
 
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        std::string translateActiveException() const override;
-        std::string tryTranslators() const;
-
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
+  class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry
+  {
+  public:
+    ~ExceptionTranslatorRegistry();
+    virtual void registerTranslator(const IExceptionTranslator *translator);
+    std::string  translateActiveException() const override;
+    std::string  tryTranslators() const;
+
+  private:
+    std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+  };
+} // namespace Catch
 
 // end catch_exception_translator_registry.h
 #ifdef __OBJC__
@@ -10294,302 +11284,299 @@ namespace Catch {
 
 namespace Catch {
 
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
+  ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {}
 
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
+  void ExceptionTranslatorRegistry::registerTranslator(const IExceptionTranslator *translator)
+  {
+    m_translators.push_back(std::unique_ptr<const IExceptionTranslator>(translator));
+  }
 
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
+  std::string ExceptionTranslatorRegistry::translateActiveException() const
+  {
+    try {
 #ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
+      // In Objective-C try objective-c exceptions first
+      @try {
+        return tryTranslators();
+      }
+      @catch (NSException *exception) {
+        return Catch::Detail::stringify([exception description]);
+      }
 #else
-            // Compiling a mixed mode project with MSVC means that CLR
-            // exceptions will be caught in (...) as well. However, these
-            // do not fill-in std::current_exception and thus lead to crash
-            // when attempting rethrow.
-            // /EHa switch also causes structured exceptions to be caught
-            // here, but they fill-in current_exception properly, so
-            // at worst the output should be a little weird, instead of
-            // causing a crash.
-            if (std::current_exception() == nullptr) {
-                return "Non C++ exception. Possibly a CLR exception.";
-            }
-            return tryTranslators();
+      // Compiling a mixed mode project with MSVC means that CLR
+      // exceptions will be caught in (...) as well. However, these
+      // do not fill-in std::current_exception and thus lead to crash
+      // when attempting rethrow.
+      // /EHa switch also causes structured exceptions to be caught
+      // here, but they fill-in current_exception properly, so
+      // at worst the output should be a little weird, instead of
+      // causing a crash.
+      if (std::current_exception() == nullptr) {
+        return "Non C++ exception. Possibly a CLR exception.";
+      }
+      return tryTranslators();
 #endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
     }
+    catch (TestFailureException &) {
+      std::rethrow_exception(std::current_exception());
+    }
+    catch (std::exception &ex) {
+      return ex.what();
+    }
+    catch (std::string &msg) {
+      return msg;
+    }
+    catch (const char *msg) {
+      return msg;
+    }
+    catch (...) {
+      return "Unknown exception";
+    }
+  }
 
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if (m_translators.empty()) {
-            std::rethrow_exception(std::current_exception());
-        } else {
-            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
-        }
+  std::string ExceptionTranslatorRegistry::tryTranslators() const
+  {
+    if (m_translators.empty()) {
+      std::rethrow_exception(std::current_exception());
     }
+    else {
+      return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+    }
+  }
 
 #else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
+  std::string ExceptionTranslatorRegistry::translateActiveException() const
+  {
+    CATCH_INTERNAL_ERROR(
+        "Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+  }
 
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
+  std::string ExceptionTranslatorRegistry::tryTranslators() const
+  {
+    CATCH_INTERNAL_ERROR(
+        "Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+  }
 #endif
 
-}
+} // namespace Catch
 // end catch_exception_translator_registry.cpp
 // start catch_fatal_condition.cpp
 
 #if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 #endif
 
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+#if defined(CATCH_CONFIG_WINDOWS_SEH) || defined(CATCH_CONFIG_POSIX_SIGNALS)
 
 namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
+  // Report the error condition
+  void reportFatal(char const *const message)
+  {
+    Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition(message);
+  }
+} // namespace
 
 #endif // signals/SEH handling
 
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
+#if defined(CATCH_CONFIG_WINDOWS_SEH)
 
 namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
-        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
-        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
-        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
-    };
+  struct SignalDefs
+  {
+    DWORD       id;
+    const char *name;
+  };
+
+  // There is no 1-1 mapping between signals and windows exceptions.
+  // Windows can easily distinguish between SO and SigSegV,
+  // but SigInt, SigTerm, etc are handled differently.
+  static SignalDefs signalDefs[] = {
+      {static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION), "SIGILL - Illegal instruction signal"},
+      {static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow"},
+      {static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal"},
+      {static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error"},
+  };
+
+  LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo)
+  {
+    for (auto const &def : signalDefs) {
+      if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+        reportFatal(def.name);
+      }
+    }
+    // If its not an exception we care about, pass it along.
+    // This stops us from eating debugger breaks etc.
+    return EXCEPTION_CONTINUE_SEARCH;
+  }
 
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
+  FatalConditionHandler::FatalConditionHandler()
+  {
+    isSet = true;
+    // 32k seems enough for Catch to handle stack overflow,
+    // but the value was found experimentally, so there is no strong guarantee
+    guaranteeSize          = 32 * 1024;
+    exceptionHandlerHandle = nullptr;
+    // Register as first handler in current chain
+    exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+    // Pass in guarantee size to be filled
+    SetThreadStackGuarantee(&guaranteeSize);
+  }
 
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
+  void FatalConditionHandler::reset()
+  {
+    if (isSet) {
+      RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+      SetThreadStackGuarantee(&guaranteeSize);
+      exceptionHandlerHandle = nullptr;
+      isSet                  = false;
     }
+  }
 
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
+  FatalConditionHandler::~FatalConditionHandler() { reset(); }
+
+  bool  FatalConditionHandler::isSet                  = false;
+  ULONG FatalConditionHandler::guaranteeSize          = 0;
+  PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
 
 } // namespace Catch
 
-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
+#elif defined(CATCH_CONFIG_POSIX_SIGNALS)
 
 namespace Catch {
 
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    // 32kb for the alternate stack seems to be sufficient. However, this value
-    // is experimentally determined, so that's not guaranteed.
-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
+  struct SignalDefs
+  {
+    int         id;
+    const char *name;
+  };
+
+  // 32kb for the alternate stack seems to be sufficient. However, this value
+  // is experimentally determined, so that's not guaranteed.
+  static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+
+  static SignalDefs signalDefs[] = {{SIGINT, "SIGINT - Terminal interrupt signal"},
+                                    {SIGILL, "SIGILL - Illegal instruction signal"},
+                                    {SIGFPE, "SIGFPE - Floating point error signal"},
+                                    {SIGSEGV, "SIGSEGV - Segmentation violation signal"},
+                                    {SIGTERM, "SIGTERM - Termination request signal"},
+                                    {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}};
+
+  void FatalConditionHandler::handleSignal(int sig)
+  {
+    char const *name = "<unknown signal>";
+    for (auto const &def : signalDefs) {
+      if (sig == def.id) {
+        name = def.name;
+        break;
+      }
+    }
+    reset();
+    reportFatal(name);
+    raise(sig);
+  }
 
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = sigStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
+  FatalConditionHandler::FatalConditionHandler()
+  {
+    isSet = true;
+    stack_t sigStack;
+    sigStack.ss_sp    = altStackMem;
+    sigStack.ss_size  = sigStackSize;
+    sigStack.ss_flags = 0;
+    sigaltstack(&sigStack, &oldSigStack);
+    struct sigaction sa = {};
+
+    sa.sa_handler = handleSignal;
+    sa.sa_flags   = SA_ONSTACK;
+    for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+      sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
     }
+  }
 
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
+  FatalConditionHandler::~FatalConditionHandler() { reset(); }
 
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
+  void FatalConditionHandler::reset()
+  {
+    if (isSet) {
+      // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+      for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+        sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+      }
+      // Return the old stack
+      sigaltstack(&oldSigStack, nullptr);
+      isSet = false;
     }
+  }
 
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[sigStackSize] = {};
+  bool             FatalConditionHandler::isSet = false;
+  struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)] =
+      {};
+  stack_t FatalConditionHandler::oldSigStack               = {};
+  char    FatalConditionHandler::altStackMem[sigStackSize] = {};
 
 } // namespace Catch
 
 #else
 
 namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
+  void FatalConditionHandler::reset() {}
+} // namespace Catch
 
 #endif // signals/SEH handling
 
 #if defined(__GNUC__)
-#    pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif
 // end catch_fatal_condition.cpp
 // start catch_generators.cpp
 
-// start catch_random_number_generator.h
-
-#include <algorithm>
-#include <random>
-
-namespace Catch {
-
-    struct IConfig;
-
-    std::mt19937& rng();
-    void seedRng( IConfig const& config );
-    unsigned int rngSeed();
-
-}
-
-// end catch_random_number_generator.h
 #include <limits>
 #include <set>
 
 namespace Catch {
 
-IGeneratorTracker::~IGeneratorTracker() {}
+  IGeneratorTracker::~IGeneratorTracker() {}
 
-const char* GeneratorException::what() const noexcept {
-    return m_msg;
-}
+  const char *GeneratorException::what() const noexcept { return m_msg; }
 
-namespace Generators {
+  namespace Generators {
 
     GeneratorUntypedBase::~GeneratorUntypedBase() {}
 
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( lineInfo );
+    auto acquireGeneratorTracker(SourceLineInfo const &lineInfo) -> IGeneratorTracker &
+    {
+      return getResultCapture().acquireGeneratorTracker(lineInfo);
     }
 
-} // namespace Generators
+  } // namespace Generators
 } // namespace Catch
 // end catch_generators.cpp
 // start catch_interfaces_capture.cpp
 
 namespace Catch {
-    IResultCapture::~IResultCapture() = default;
+  IResultCapture::~IResultCapture() = default;
 }
 // end catch_interfaces_capture.cpp
 // start catch_interfaces_config.cpp
 
 namespace Catch {
-    IConfig::~IConfig() = default;
+  IConfig::~IConfig() = default;
 }
 // end catch_interfaces_config.cpp
 // start catch_interfaces_exception.cpp
 
 namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
+  IExceptionTranslator::~IExceptionTranslator()                 = default;
+  IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+} // namespace Catch
 // end catch_interfaces_exception.cpp
 // start catch_interfaces_registry_hub.cpp
 
 namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
+  IRegistryHub::~IRegistryHub()               = default;
+  IMutableRegistryHub::~IMutableRegistryHub() = default;
+} // namespace Catch
 // end catch_interfaces_registry_hub.cpp
 // start catch_interfaces_reporter.cpp
 
@@ -10597,168 +11584,156 @@ namespace Catch {
 
 namespace Catch {
 
-    class ListeningReporter : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
-        ReporterPreferences m_preferences;
+  class ListeningReporter : public IStreamingReporter
+  {
+    using Reporters = std::vector<IStreamingReporterPtr>;
+    Reporters             m_listeners;
+    IStreamingReporterPtr m_reporter = nullptr;
+    ReporterPreferences   m_preferences;
 
-    public:
-        ListeningReporter();
+  public:
+    ListeningReporter();
 
-        void addListener( IStreamingReporterPtr&& listener );
-        void addReporter( IStreamingReporterPtr&& reporter );
+    void addListener(IStreamingReporterPtr &&listener);
+    void addReporter(IStreamingReporterPtr &&reporter);
 
-    public: // IStreamingReporter
+  public: // IStreamingReporter
+    ReporterPreferences getPreferences() const override;
 
-        ReporterPreferences getPreferences() const override;
+    void noMatchingTestCases(std::string const &spec) override;
 
-        void noMatchingTestCases( std::string const& spec ) override;
+    void reportInvalidArguments(std::string const &arg) override;
 
-        static std::set<Verbosity> getSupportedVerbosities();
+    static std::set<Verbosity> getSupportedVerbosities();
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed(std::string const&) override;
+    void benchmarkPreparing(std::string const &name) override;
+    void benchmarkStarting(BenchmarkInfo const &benchmarkInfo) override;
+    void benchmarkEnded(BenchmarkStats<> const &benchmarkStats) override;
+    void benchmarkFailed(std::string const &) override;
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
+    void testRunStarting(TestRunInfo const &testRunInfo) override;
+    void testGroupStarting(GroupInfo const &groupInfo) override;
+    void testCaseStarting(TestCaseInfo const &testInfo) override;
+    void sectionStarting(SectionInfo const &sectionInfo) override;
+    void assertionStarting(AssertionInfo const &assertionInfo) override;
 
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
+    // The return value indicates if the messages buffer should be cleared:
+    bool assertionEnded(AssertionStats const &assertionStats) override;
+    void sectionEnded(SectionStats const &sectionStats) override;
+    void testCaseEnded(TestCaseStats const &testCaseStats) override;
+    void testGroupEnded(TestGroupStats const &testGroupStats) override;
+    void testRunEnded(TestRunStats const &testRunStats) override;
 
-    };
+    void skipTest(TestCaseInfo const &testInfo) override;
+    bool isMulti() const override;
+  };
 
 } // end namespace Catch
 
 // end catch_reporter_listening.h
 namespace Catch {
 
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+  ReporterConfig::ReporterConfig(IConfigPtr const &_fullConfig)
+      : m_stream(&_fullConfig->stream()), m_fullConfig(_fullConfig)
+  {
+  }
 
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+  ReporterConfig::ReporterConfig(IConfigPtr const &_fullConfig, std::ostream &_stream)
+      : m_stream(&_stream), m_fullConfig(_fullConfig)
+  {
+  }
 
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
+  std::ostream &ReporterConfig::stream() const { return *m_stream; }
+  IConfigPtr    ReporterConfig::fullConfig() const { return m_fullConfig; }
 
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
+  TestRunInfo::TestRunInfo(std::string const &_name) : name(_name) {}
 
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
+  GroupInfo::GroupInfo(std::string const &_name, std::size_t _groupIndex, std::size_t _groupsCount)
+      : name(_name), groupIndex(_groupIndex), groupsCounts(_groupsCount)
+  {
+  }
 
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
+  AssertionStats::AssertionStats(AssertionResult const &         _assertionResult,
+                                 std::vector<MessageInfo> const &_infoMessages,
+                                 Totals const &                  _totals)
+      : assertionResult(_assertionResult), infoMessages(_infoMessages), totals(_totals)
+  {
+    assertionResult.m_resultData.lazyExpression.m_transientExpression =
+        _assertionResult.m_resultData.lazyExpression.m_transientExpression;
 
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
+    if (assertionResult.hasMessage()) {
+      // Copy message into messages list.
+      // !TBD This should have been done earlier, somewhere
+      MessageBuilder builder(assertionResult.getTestMacroName(), assertionResult.getSourceInfo(),
+                             assertionResult.getResultType());
+      builder << assertionResult.getMessage();
+      builder.m_info.message = builder.m_stream.str();
 
-            infoMessages.push_back( builder.m_info );
-        }
+      infoMessages.push_back(builder.m_info);
     }
+  }
+
+  AssertionStats::~AssertionStats() = default;
+
+  SectionStats::SectionStats(SectionInfo const &_sectionInfo, Counts const &_assertions,
+                             double _durationInSeconds, bool _missingAssertions)
+      : sectionInfo(_sectionInfo), assertions(_assertions), durationInSeconds(_durationInSeconds),
+        missingAssertions(_missingAssertions)
+  {
+  }
+
+  SectionStats::~SectionStats() = default;
+
+  TestCaseStats::TestCaseStats(TestCaseInfo const &_testInfo, Totals const &_totals,
+                               std::string const &_stdOut, std::string const &_stdErr,
+                               bool _aborting)
+      : testInfo(_testInfo), totals(_totals), stdOut(_stdOut), stdErr(_stdErr), aborting(_aborting)
+  {
+  }
+
+  TestCaseStats::~TestCaseStats() = default;
+
+  TestGroupStats::TestGroupStats(GroupInfo const &_groupInfo, Totals const &_totals, bool _aborting)
+      : groupInfo(_groupInfo), totals(_totals), aborting(_aborting)
+  {
+  }
+
+  TestGroupStats::TestGroupStats(GroupInfo const &_groupInfo)
+      : groupInfo(_groupInfo), aborting(false)
+  {
+  }
+
+  TestGroupStats::~TestGroupStats() = default;
+
+  TestRunStats::TestRunStats(TestRunInfo const &_runInfo, Totals const &_totals, bool _aborting)
+      : runInfo(_runInfo), totals(_totals), aborting(_aborting)
+  {
+  }
 
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
+  TestRunStats::~TestRunStats() = default;
+
+  void IStreamingReporter::fatalErrorEncountered(StringRef) {}
+  bool IStreamingReporter::isMulti() const { return false; }
+
+  IReporterFactory::~IReporterFactory()   = default;
+  IReporterRegistry::~IReporterRegistry() = default;
 
 } // end namespace Catch
 // end catch_interfaces_reporter.cpp
 // start catch_interfaces_runner.cpp
 
 namespace Catch {
-    IRunner::~IRunner() = default;
+  IRunner::~IRunner() = default;
 }
 // end catch_interfaces_runner.cpp
 // start catch_interfaces_testcase.cpp
 
 namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
+  ITestInvoker::~ITestInvoker()           = default;
+  ITestCaseRegistry::~ITestCaseRegistry() = default;
+} // namespace Catch
 // end catch_interfaces_testcase.cpp
 // start catch_leak_detector.cpp
 
@@ -10767,27 +11742,26 @@ namespace Catch {
 
 namespace Catch {
 
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
+  LeakDetector::LeakDetector()
+  {
+    int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+    flag |= _CRTDBG_LEAK_CHECK_DF;
+    flag |= _CRTDBG_ALLOC_MEM_DF;
+    _CrtSetDbgFlag(flag);
+    _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+    _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+    // Change this to leaking allocation's number to break there
+    _CrtSetBreakAlloc(-1);
+  }
+} // namespace Catch
 
 #else
 
-    Catch::LeakDetector::LeakDetector() {}
+Catch::LeakDetector::LeakDetector() {}
 
 #endif
 
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
+Catch::LeakDetector::~LeakDetector() { Catch::cleanUp(); }
 // end catch_leak_detector.cpp
 // start catch_list.cpp
 
@@ -10797,23 +11771,24 @@ Catch::LeakDetector::~LeakDetector() {
 
 namespace Catch {
 
-    std::size_t listTests( Config const& config );
+  std::size_t listTests(Config const &config);
 
-    std::size_t listTestsNamesOnly( Config const& config );
+  std::size_t listTestsNamesOnly(Config const &config);
 
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
+  struct TagInfo
+  {
+    void        add(std::string const &spelling);
+    std::string all() const;
 
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
+    std::set<std::string> spellings;
+    std::size_t           count = 0;
+  };
 
-    std::size_t listTags( Config const& config );
+  std::size_t listTags(Config const &config);
 
-    std::size_t listReporters();
+  std::size_t listReporters();
 
-    Option<std::size_t> list( std::shared_ptr<Config> const& config );
+  Option<std::size_t> list(std::shared_ptr<Config> const &config);
 
 } // end namespace Catch
 
@@ -10821,191 +11796,226 @@ namespace Catch {
 // start catch_text.h
 
 namespace Catch {
-    using namespace clara::TextFlow;
+  using namespace clara::TextFlow;
 }
 
 // end catch_text.h
-#include <limits>
 #include <algorithm>
 #include <iomanip>
+#include <limits>
 
 namespace Catch {
 
-    std::size_t listTests( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-        }
+  std::size_t listTests(Config const &config)
+  {
+    TestSpec testSpec = config.testSpec();
+    if (config.hasTestFilters())
+      Catch::cout() << "Matching test cases:\n";
+    else {
+      Catch::cout() << "All available test cases:\n";
+    }
+
+    auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+    for (auto const &testCaseInfo : matchedTestCases) {
+      Colour::Code colour = testCaseInfo.isHidden() ? Colour::SecondaryText : Colour::None;
+      Colour       colourGuard(colour);
+
+      Catch::cout() << Column(testCaseInfo.name).initialIndent(2).indent(4) << "\n";
+      if (config.verbosity() >= Verbosity::High) {
+        Catch::cout() << Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4)
+                      << std::endl;
+        std::string description = testCaseInfo.description;
+        if (description.empty())
+          description = "(NO DESCRIPTION)";
+        Catch::cout() << Column(description).indent(4) << std::endl;
+      }
+      if (!testCaseInfo.tags.empty())
+        Catch::cout() << Column(testCaseInfo.tagsAsString()).indent(6) << "\n";
+    }
+
+    if (!config.hasTestFilters())
+      Catch::cout() << pluralise(matchedTestCases.size(), "test case") << '\n' << std::endl;
+    else
+      Catch::cout() << pluralise(matchedTestCases.size(), "matching test case") << '\n'
+                    << std::endl;
+    return matchedTestCases.size();
+  }
 
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
+  std::size_t listTestsNamesOnly(Config const &config)
+  {
+    TestSpec              testSpec     = config.testSpec();
+    std::size_t           matchedTests = 0;
+    std::vector<TestCase> matchedTestCases =
+        filterTests(getAllTestCasesSorted(config), testSpec, config);
+    for (auto const &testCaseInfo : matchedTestCases) {
+      matchedTests++;
+      if (startsWith(testCaseInfo.name, '#'))
+        Catch::cout() << '"' << testCaseInfo.name << '"';
+      else
+        Catch::cout() << testCaseInfo.name;
+      if (config.verbosity() >= Verbosity::High)
+        Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+      Catch::cout() << std::endl;
+    }
+    return matchedTests;
+  }
 
-        if( !config.hasTestFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
+  void TagInfo::add(std::string const &spelling)
+  {
+    ++count;
+    spellings.insert(spelling);
+  }
 
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
+  std::string TagInfo::all() const
+  {
+    size_t size = 0;
+    for (auto const &spelling : spellings) {
+      // Add 2 for the brackes
+      size += spelling.size() + 2;
     }
 
-    std::string TagInfo::all() const {
-        size_t size = 0;
-        for (auto const& spelling : spellings) {
-            // Add 2 for the brackes
-            size += spelling.size() + 2;
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
-        return out;
+    std::string out;
+    out.reserve(size);
+    for (auto const &spelling : spellings) {
+      out += '[';
+      out += spelling;
+      out += ']';
     }
+    return out;
+  }
 
-    std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
+  std::size_t listTags(Config const &config)
+  {
+    TestSpec testSpec = config.testSpec();
+    if (config.hasTestFilters())
+      Catch::cout() << "Tags for matching test cases:\n";
+    else {
+      Catch::cout() << "All available tags:\n";
+    }
+
+    std::map<std::string, TagInfo> tagCounts;
+
+    std::vector<TestCase> matchedTestCases =
+        filterTests(getAllTestCasesSorted(config), testSpec, config);
+    for (auto const &testCase : matchedTestCases) {
+      for (auto const &tagName : testCase.getTestCaseInfo().tags) {
+        std::string lcaseTagName = toLower(tagName);
+        auto        countIt      = tagCounts.find(lcaseTagName);
+        if (countIt == tagCounts.end())
+          countIt = tagCounts.insert(std::make_pair(lcaseTagName, TagInfo())).first;
+        countIt->second.add(tagName);
+      }
+    }
+
+    for (auto const &tagCount : tagCounts) {
+      ReusableStringStream rss;
+      rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+      auto str     = rss.str();
+      auto wrapper = Column(tagCount.second.all())
+                         .initialIndent(0)
+                         .indent(str.size())
+                         .width(CATCH_CONFIG_CONSOLE_WIDTH - 10);
+      Catch::cout() << str << wrapper << '\n';
+    }
+    Catch::cout() << pluralise(tagCounts.size(), "tag") << '\n' << std::endl;
+    return tagCounts.size();
+  }
 
-        for( auto const& tagCount : tagCounts ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto str = rss.str();
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( str.size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << str << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters() {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+  std::size_t listReporters()
+  {
+    Catch::cout() << "Available reporters:\n";
+    IReporterRegistry::FactoryMap const &factories =
+        getRegistryHub().getReporterRegistry().getFactories();
+    std::size_t maxNameLen = 0;
+    for (auto const &factoryKvp : factories)
+      maxNameLen = (std::max)(maxNameLen, factoryKvp.first.size());
+
+    for (auto const &factoryKvp : factories) {
+      Catch::cout() << Column(factoryKvp.first + ":").indent(2).width(5 + maxNameLen) +
+                           Column(factoryKvp.second->getDescription())
+                               .initialIndent(0)
+                               .indent(2)
+                               .width(CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8)
                     << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
     }
+    Catch::cout() << std::endl;
+    return factories.size();
+  }
 
-    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
-        Option<std::size_t> listedCount;
-        getCurrentMutableContext().setConfig( config );
-        if( config->listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( *config );
-        if( config->listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
-        if( config->listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( *config );
-        if( config->listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters();
-        return listedCount;
-    }
+  Option<std::size_t> list(std::shared_ptr<Config> const &config)
+  {
+    Option<std::size_t> listedCount;
+    getCurrentMutableContext().setConfig(config);
+    if (config->listTests())
+      listedCount = listedCount.valueOr(0) + listTests(*config);
+    if (config->listTestNamesOnly())
+      listedCount = listedCount.valueOr(0) + listTestsNamesOnly(*config);
+    if (config->listTags())
+      listedCount = listedCount.valueOr(0) + listTags(*config);
+    if (config->listReporters())
+      listedCount = listedCount.valueOr(0) + listReporters();
+    return listedCount;
+  }
 
 } // end namespace Catch
 // end catch_list.cpp
 // start catch_matchers.cpp
 
 namespace Catch {
-namespace Matchers {
+  namespace Matchers {
     namespace Impl {
 
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
+      std::string MatcherUntypedBase::toString() const
+      {
+        if (m_cachedToString.empty())
+          m_cachedToString = describe();
+        return m_cachedToString;
+      }
 
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
+      MatcherUntypedBase::~MatcherUntypedBase() = default;
 
     } // namespace Impl
-} // namespace Matchers
+  }   // namespace Matchers
 
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
+  using namespace Matchers;
+  using Matchers::Impl::MatcherBase;
 
 } // namespace Catch
 // end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+  namespace Matchers {
+    namespace Exception {
+
+      bool ExceptionMessageMatcher::match(std::exception const &ex) const
+      {
+        return ex.what() == m_message;
+      }
+
+      std::string ExceptionMessageMatcher::describe() const
+      {
+        return "exception message matches \"" + m_message + "\"";
+      }
+
+    } // namespace Exception
+    Exception::ExceptionMessageMatcher Message(std::string const &message)
+    {
+      return Exception::ExceptionMessageMatcher(message);
+    }
+
+    // namespace Exception
+  } // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
 // start catch_matchers_floating.cpp
 
 // start catch_polyfills.hpp
 
 namespace Catch {
-    bool isnan(float f);
-    bool isnan(double d);
-}
+  bool isnan(float f);
+  bool isnan(double d);
+} // namespace Catch
 
 // end catch_polyfills.hpp
 // start catch_to_string.hpp
@@ -11013,119 +12023,151 @@ namespace Catch {
 #include <string>
 
 namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
+  template <typename T> std::string to_string(T const &t)
+  {
 #if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
+    return std::to_string(t);
 #else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
+    ReusableStringStream rss;
+    rss << t;
+    return rss.str();
 #endif
-    }
+  }
 } // end namespace Catch
 
 // end catch_to_string.hpp
-#include <cstdlib>
+#include <algorithm>
+#include <cmath>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
-#include <sstream>
 #include <iomanip>
 #include <limits>
+#include <sstream>
+#include <type_traits>
 
 namespace Catch {
-namespace Matchers {
-namespace Floating {
-enum class FloatingPointKind : uint8_t {
-    Float,
-    Double
-};
-}
-}
-}
-
-namespace {
-
-template <typename T>
-struct Converter;
-
-template <>
-struct Converter<float> {
-    static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-    Converter(float f) {
-        std::memcpy(&i, &f, sizeof(f));
-    }
-    int32_t i;
-};
+  namespace {
 
-template <>
-struct Converter<double> {
-    static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-    Converter(double d) {
-        std::memcpy(&i, &d, sizeof(d));
+    int32_t convert(float f)
+    {
+      static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+      int32_t i;
+      std::memcpy(&i, &f, sizeof(f));
+      return i;
     }
-    int64_t i;
-};
 
-template <typename T>
-auto convert(T t) -> Converter<T> {
-    return Converter<T>(t);
-}
+    int64_t convert(double d)
+    {
+      static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+      int64_t i;
+      std::memcpy(&i, &d, sizeof(d));
+      return i;
+    }
 
-template <typename FP>
-bool almostEqualUlps(FP lhs, FP rhs, int maxUlpDiff) {
-    // Comparison with NaN should always be false.
-    // This way we can rule it out before getting into the ugly details
-    if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+    template <typename FP> bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff)
+    {
+      // Comparison with NaN should always be false.
+      // This way we can rule it out before getting into the ugly details
+      if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
         return false;
-    }
+      }
 
-    auto lc = convert(lhs);
-    auto rc = convert(rhs);
+      auto lc = convert(lhs);
+      auto rc = convert(rhs);
 
-    if ((lc.i < 0) != (rc.i < 0)) {
+      if ((lc < 0) != (rc < 0)) {
         // Potentially we can have +0 and -0
         return lhs == rhs;
+      }
+
+      auto ulpDiff = std::abs(lc - rc);
+      return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
     }
 
-    auto ulpDiff = std::abs(lc.i - rc.i);
-    return ulpDiff <= maxUlpDiff;
-}
+  } // end anonymous namespace
 
-template <typename FP>
-FP step(FP start, FP direction, int steps) {
-    for (int i = 0; i < steps; ++i) {
-        start = std::nextafter(start, direction);
-    }
-    return start;
-}
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
 
-} // end anonymous namespace
+#if defined(__clang__)
+#pragma clang diagnostic push
+// The long double overload is currently unused
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
 
-namespace Catch {
-namespace Matchers {
-namespace Floating {
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
+  float nextafter(float x, float y) { return ::nextafterf(x, y); }
+
+  double nextafter(double x, double y) { return ::nextafter(x, y); }
+
+  long double nextafter(long double x, long double y) { return ::nextafterl(x, y); }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+  namespace {
+
+    template <typename FP> FP step(FP start, FP direction, uint64_t steps)
+    {
+      for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+      }
+      return start;
     }
 
     // Performs equivalent check of std::fabs(lhs - rhs) <= margin
     // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    bool marginComparison(double lhs, double rhs, double margin)
+    {
+      return (lhs + margin >= rhs) && (rhs + margin >= lhs);
     }
 
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    template <typename FloatingPoint> void write(std::ostream &out, FloatingPoint num)
+    {
+      out << std::scientific
+          << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1) << num;
     }
 
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(ulps >= 0, "Invalid ULP setting: " << ulps << '.'
-            << " ULPs have to be non-negative.");
-    }
+  } // end anonymous namespace
+
+  namespace Matchers {
+    namespace Floating {
+
+      enum class FloatingPointKind : uint8_t { Float, Double };
+
+      WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+          : m_target{target}, m_margin{margin}
+      {
+        CATCH_ENFORCE(margin >= 0,
+                      "Invalid margin: " << margin << '.' << " Margin has to be non-negative.");
+      }
+
+      // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+      // But without the subtraction to allow for INFINITY in comparison
+      bool WithinAbsMatcher::match(double const &matchee) const
+      {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+      }
+
+      std::string WithinAbsMatcher::describe() const
+      {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " +
+               ::Catch::Detail::stringify(m_target);
+      }
+
+      WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
+          : m_target{target}, m_ulps{ulps}, m_type{baseType}
+      {
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double ||
+                          m_ulps < (std::numeric_limits<uint32_t>::max)(),
+                      "Provided ULP is impossibly large for a float comparison.");
+      }
 
 #if defined(__clang__)
 #pragma clang diagnostic push
@@ -11133,73 +12175,124 @@ namespace Floating {
 #pragma clang diagnostic ignored "-Wunreachable-code"
 #endif
 
-    bool WithinUlpsMatcher::match(double const& matchee) const {
+      bool WithinUlpsMatcher::match(double const &matchee) const
+      {
         switch (m_type) {
         case FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+          return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target),
+                                        m_ulps);
+        case FloatingPointKind::Double: return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default: CATCH_INTERNAL_ERROR("Unknown FloatingPointKind value");
         }
-    }
+      }
 
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
 
-    std::string WithinUlpsMatcher::describe() const {
+      std::string WithinUlpsMatcher::describe() const
+      {
         std::stringstream ret;
 
-        ret << "is within " << m_ulps << " ULPs of " << ::Catch::Detail::stringify(m_target);
+        ret << "is within " << m_ulps << " ULPs of ";
 
         if (m_type == FloatingPointKind::Float) {
-            ret << 'f';
+          write(ret, static_cast<float>(m_target));
+          ret << 'f';
+        }
+        else {
+          write(ret, m_target);
         }
 
         ret << " ([";
-        ret << std::fixed << std::setprecision(std::numeric_limits<double>::max_digits10);
         if (m_type == FloatingPointKind::Double) {
-            ret << step(m_target, static_cast<double>(-INFINITY), m_ulps)
-                << ", "
-                << step(m_target, static_cast<double>(INFINITY), m_ulps);
-        } else {
-            ret << step<float>(static_cast<float>(m_target), -INFINITY, m_ulps)
-                << ", "
-                << step<float>(static_cast<float>(m_target), INFINITY, m_ulps);
+          write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+          ret << ", ";
+          write(ret, step(m_target, static_cast<double>(INFINITY), m_ulps));
+        }
+        else {
+          // We have to cast INFINITY to float because of MinGW, see #1782
+          write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+          ret << ", ";
+          write(ret, step(static_cast<float>(m_target), static_cast<float>(INFINITY), m_ulps));
         }
         ret << "])";
 
         return ret.str();
-        //return "is within " + Catch::to_string(m_ulps) + " ULPs of " + ::Catch::Detail::stringify(m_target) + ((m_type == FloatingPointKind::Float)? "f" : "");
+      }
+
+      WithinRelMatcher::WithinRelMatcher(double target, double epsilon)
+          : m_target(target), m_epsilon(epsilon)
+      {
+        CATCH_ENFORCE(m_epsilon >= 0.,
+                      "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+      }
+
+      bool WithinRelMatcher::match(double const &matchee) const
+      {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target, std::isinf(relMargin) ? 0 : relMargin);
+      }
+
+      std::string WithinRelMatcher::describe() const
+      {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+      }
+
+    } // namespace Floating
+
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff)
+    {
+      return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
     }
 
-}// namespace Floating
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff)
+    {
+      return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+    }
 
-Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
-}
+    Floating::WithinAbsMatcher WithinAbs(double target, double margin)
+    {
+      return Floating::WithinAbsMatcher(target, margin);
+    }
 
-Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
-}
+    Floating::WithinRelMatcher WithinRel(double target, double eps)
+    {
+      return Floating::WithinRelMatcher(target, eps);
+    }
 
-Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
-    return Floating::WithinAbsMatcher(target, margin);
-}
+    Floating::WithinRelMatcher WithinRel(double target)
+    {
+      return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+    }
+
+    Floating::WithinRelMatcher WithinRel(float target, float eps)
+    {
+      return Floating::WithinRelMatcher(target, eps);
+    }
+
+    Floating::WithinRelMatcher WithinRel(float target)
+    {
+      return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+    }
 
-} // namespace Matchers
+  } // namespace Matchers
 } // namespace Catch
 
 // end catch_matchers_floating.cpp
 // start catch_matchers_generic.cpp
 
-std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string &desc)
+{
+  if (desc.empty()) {
+    return "matches undescribed predicate";
+  }
+  else {
+    return "matches predicate: \"" + desc + '"';
+  }
 }
 // end catch_matchers_generic.cpp
 // start catch_matchers_string.cpp
@@ -11207,101 +12300,132 @@ std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::str
 #include <regex>
 
 namespace Catch {
-namespace Matchers {
+  namespace Matchers {
 
     namespace StdString {
 
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
-
-        bool RegexMatcher::match(std::string const& matchee) const {
-            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-            if (m_caseSensitivity == CaseSensitive::Choice::No) {
-                flags |= std::regex::icase;
-            }
-            auto reg = std::regex(m_regex, flags);
-            return std::regex_match(matchee, reg);
-        }
-
-        std::string RegexMatcher::describe() const {
-            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
-        }
+      CasedString::CasedString(std::string const &str, CaseSensitive::Choice caseSensitivity)
+          : m_caseSensitivity(caseSensitivity), m_str(adjustString(str))
+      {
+      }
+      std::string CasedString::adjustString(std::string const &str) const
+      {
+        return m_caseSensitivity == CaseSensitive::No ? toLower(str) : str;
+      }
+      std::string CasedString::caseSensitivitySuffix() const
+      {
+        return m_caseSensitivity == CaseSensitive::No ? " (case insensitive)" : std::string();
+      }
+
+      StringMatcherBase::StringMatcherBase(std::string const &operation,
+                                           CasedString const &comparator)
+          : m_comparator(comparator), m_operation(operation)
+      {
+      }
+
+      std::string StringMatcherBase::describe() const
+      {
+        std::string description;
+        description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                            m_comparator.caseSensitivitySuffix().size());
+        description += m_operation;
+        description += ": \"";
+        description += m_comparator.m_str;
+        description += "\"";
+        description += m_comparator.caseSensitivitySuffix();
+        return description;
+      }
+
+      EqualsMatcher::EqualsMatcher(CasedString const &comparator)
+          : StringMatcherBase("equals", comparator)
+      {
+      }
+
+      bool EqualsMatcher::match(std::string const &source) const
+      {
+        return m_comparator.adjustString(source) == m_comparator.m_str;
+      }
+
+      ContainsMatcher::ContainsMatcher(CasedString const &comparator)
+          : StringMatcherBase("contains", comparator)
+      {
+      }
+
+      bool ContainsMatcher::match(std::string const &source) const
+      {
+        return contains(m_comparator.adjustString(source), m_comparator.m_str);
+      }
+
+      StartsWithMatcher::StartsWithMatcher(CasedString const &comparator)
+          : StringMatcherBase("starts with", comparator)
+      {
+      }
+
+      bool StartsWithMatcher::match(std::string const &source) const
+      {
+        return startsWith(m_comparator.adjustString(source), m_comparator.m_str);
+      }
+
+      EndsWithMatcher::EndsWithMatcher(CasedString const &comparator)
+          : StringMatcherBase("ends with", comparator)
+      {
+      }
+
+      bool EndsWithMatcher::match(std::string const &source) const
+      {
+        return endsWith(m_comparator.adjustString(source), m_comparator.m_str);
+      }
+
+      RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity)
+          : m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity)
+      {
+      }
+
+      bool RegexMatcher::match(std::string const &matchee) const
+      {
+        auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+        if (m_caseSensitivity == CaseSensitive::Choice::No) {
+          flags |= std::regex::icase;
+        }
+        auto reg = std::regex(m_regex, flags);
+        return std::regex_match(matchee, reg);
+      }
+
+      std::string RegexMatcher::describe() const
+      {
+        return "matches " + ::Catch::Detail::stringify(m_regex) +
+               ((m_caseSensitivity == CaseSensitive::Choice::Yes) ? " case sensitively"
+                                                                  : " case insensitively");
+      }
 
     } // namespace StdString
 
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    StdString::EqualsMatcher Equals(std::string const &str, CaseSensitive::Choice caseSensitivity)
+    {
+      return StdString::EqualsMatcher(StdString::CasedString(str, caseSensitivity));
     }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    StdString::ContainsMatcher Contains(std::string const &   str,
+                                        CaseSensitive::Choice caseSensitivity)
+    {
+      return StdString::ContainsMatcher(StdString::CasedString(str, caseSensitivity));
     }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    StdString::EndsWithMatcher EndsWith(std::string const &   str,
+                                        CaseSensitive::Choice caseSensitivity)
+    {
+      return StdString::EndsWithMatcher(StdString::CasedString(str, caseSensitivity));
     }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    StdString::StartsWithMatcher StartsWith(std::string const &   str,
+                                            CaseSensitive::Choice caseSensitivity)
+    {
+      return StdString::StartsWithMatcher(StdString::CasedString(str, caseSensitivity));
     }
 
-    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
-        return StdString::RegexMatcher(regex, caseSensitivity);
+    StdString::RegexMatcher Matches(std::string const &regex, CaseSensitive::Choice caseSensitivity)
+    {
+      return StdString::RegexMatcher(regex, caseSensitivity);
     }
 
-} // namespace Matchers
+  } // namespace Matchers
 } // namespace Catch
 // end catch_matchers_string.cpp
 // start catch_message.cpp
@@ -11309,7 +12433,7 @@ namespace Matchers {
 // start catch_uncaught_exceptions.h
 
 namespace Catch {
-    bool uncaught_exceptions();
+  bool uncaught_exceptions();
 } // end namespace Catch
 
 // end catch_uncaught_exceptions.h
@@ -11318,125 +12442,123 @@ namespace Catch {
 
 namespace Catch {
 
-    MessageInfo::MessageInfo(   StringRef const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
+  MessageInfo::MessageInfo(StringRef const &_macroName, SourceLineInfo const &_lineInfo,
+                           ResultWas::OfType _type)
+      : macroName(_macroName), lineInfo(_lineInfo), type(_type), sequence(++globalCount)
+  {
+  }
 
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
+  bool MessageInfo::operator==(MessageInfo const &other) const
+  {
+    return sequence == other.sequence;
+  }
 
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
+  bool MessageInfo::operator<(MessageInfo const &other) const { return sequence < other.sequence; }
 
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
+  // This may need protecting if threading support is added
+  unsigned int MessageInfo::globalCount = 0;
 
-    ////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////
 
-    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
+  Catch::MessageBuilder::MessageBuilder(StringRef const &macroName, SourceLineInfo const &lineInfo,
+                                        ResultWas::OfType type)
+      : m_info(macroName, lineInfo, type)
+  {
+  }
 
-    ////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////
 
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info ), m_moved()
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
+  ScopedMessage::ScopedMessage(MessageBuilder const &builder) : m_info(builder.m_info), m_moved()
+  {
+    m_info.message = builder.m_stream.str();
+    getResultCapture().pushScopedMessage(m_info);
+  }
 
-    ScopedMessage::ScopedMessage( ScopedMessage&& old )
-    : m_info( old.m_info ), m_moved()
-    {
-        old.m_moved = true;
-    }
+  ScopedMessage::ScopedMessage(ScopedMessage &&old) : m_info(old.m_info), m_moved()
+  {
+    old.m_moved = true;
+  }
 
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
+  ScopedMessage::~ScopedMessage()
+  {
+    if (!uncaught_exceptions() && !m_moved) {
+      getResultCapture().popScopedMessage(m_info);
     }
+  }
 
-    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(names[start])) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(names[end])) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
+  Capturer::Capturer(StringRef macroName, SourceLineInfo const &lineInfo,
+                     ResultWas::OfType resultType, StringRef names)
+  {
+    auto trimmed = [&](size_t start, size_t end) {
+      while (names[start] == ',' || isspace(names[start])) {
+        ++start;
+      }
+      while (names[end] == ',' || isspace(names[end])) {
+        --end;
+      }
+      return names.substr(start, end - start + 1);
+    };
+    auto skipq = [&](size_t start, char quote) {
+      for (auto i = start + 1; i < names.size(); ++i) {
+        if (names[i] == quote)
+          return i;
+        if (names[i] == '\\')
+          ++i;
+      }
+      CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+    };
 
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.size() == 0) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = trimmed(start, pos);
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-            }
-        }
-        assert(openings.size() == 0 && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = trimmed(start, names.size() - 1);
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
+    size_t           start = 0;
+    std::stack<char> openings;
+    for (size_t pos = 0; pos < names.size(); ++pos) {
+      char c = names[pos];
+      switch (c) {
+      case '[':
+      case '{':
+      case '(':
+        // It is basically impossible to disambiguate between
+        // comparison and start of template args in this context
+        //            case '<':
+        openings.push(c);
+        break;
+      case ']':
+      case '}':
+      case ')':
+        //           case '>':
+        openings.pop();
+        break;
+      case '"':
+      case '\'': pos = skipq(pos, c); break;
+      case ',':
+        if (start != pos && openings.size() == 0) {
+          m_messages.emplace_back(macroName, lineInfo, resultType);
+          m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+          m_messages.back().message += " := ";
+          start = pos;
+        }
+      }
+    }
+    assert(openings.size() == 0 && "Mismatched openings");
+    m_messages.emplace_back(macroName, lineInfo, resultType);
+    m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+    m_messages.back().message += " := ";
+  }
+  Capturer::~Capturer()
+  {
+    if (!uncaught_exceptions()) {
+      assert(m_captured == m_messages.size());
+      for (size_t i = 0; i < m_captured; ++i)
+        m_resultCapture.popScopedMessage(m_messages[i]);
     }
+  }
 
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
+  void Capturer::captureValue(size_t index, std::string const &value)
+  {
+    assert(index < m_messages.size());
+    m_messages[index].message += value;
+    m_resultCapture.pushScopedMessage(m_messages[index]);
+    m_captured++;
+  }
 
 } // end namespace Catch
 // end catch_message.cpp
@@ -11452,96 +12574,105 @@ namespace Catch {
 
 namespace Catch {
 
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
+  class RedirectedStream
+  {
+    std::ostream &  m_originalStream;
+    std::ostream &  m_redirectionStream;
+    std::streambuf *m_prevBuf;
+
+  public:
+    RedirectedStream(std::ostream &originalStream, std::ostream &redirectionStream);
+    ~RedirectedStream();
+  };
+
+  class RedirectedStdOut
+  {
+    ReusableStringStream m_rss;
+    RedirectedStream     m_cout;
+
+  public:
+    RedirectedStdOut();
+    auto str() const -> std::string;
+  };
+
+  // StdErr has two constituent streams in C++, std::cerr and std::clog
+  // This means that we need to redirect 2 streams into 1 to keep proper
+  // order of writes
+  class RedirectedStdErr
+  {
+    ReusableStringStream m_rss;
+    RedirectedStream     m_cerr;
+    RedirectedStream     m_clog;
+
+  public:
+    RedirectedStdErr();
+    auto str() const -> std::string;
+  };
+
+  class RedirectedStreams
+  {
+  public:
+    RedirectedStreams(RedirectedStreams const &) = delete;
+    RedirectedStreams &operator=(RedirectedStreams const &) = delete;
+    RedirectedStreams(RedirectedStreams &&)                 = delete;
+    RedirectedStreams &operator=(RedirectedStreams &&) = delete;
+
+    RedirectedStreams(std::string &redirectedCout, std::string &redirectedCerr);
+    ~RedirectedStreams();
+
+  private:
+    std::string &    m_redirectedCout;
+    std::string &    m_redirectedCerr;
+    RedirectedStdOut m_redirectedStdOut;
+    RedirectedStdErr m_redirectedStdErr;
+  };
 
 #if defined(CATCH_CONFIG_NEW_CAPTURE)
 
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-    class OutputRedirect {
-    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
-    };
+  // Windows's implementation of std::tmpfile is terrible (it tries
+  // to create a file inside system folder, thus requiring elevated
+  // privileges for the binary), so we have to use tmpnam(_s) and
+  // create the file ourselves there.
+  class TempFile
+  {
+  public:
+    TempFile(TempFile const &) = delete;
+    TempFile &operator=(TempFile const &) = delete;
+    TempFile(TempFile &&)                 = delete;
+    TempFile &operator=(TempFile &&) = delete;
+
+    TempFile();
+    ~TempFile();
+
+    std::FILE * getFile();
+    std::string getContents();
+
+  private:
+    std::FILE *m_file = nullptr;
+#if defined(_MSC_VER)
+    char m_buffer[L_tmpnam] = {0};
+#endif
+  };
+
+  class OutputRedirect
+  {
+  public:
+    OutputRedirect(OutputRedirect const &) = delete;
+    OutputRedirect &operator=(OutputRedirect const &) = delete;
+    OutputRedirect(OutputRedirect &&)                 = delete;
+    OutputRedirect &operator=(OutputRedirect &&) = delete;
+
+    OutputRedirect(std::string &stdout_dest, std::string &stderr_dest);
+    ~OutputRedirect();
+
+  private:
+    int          m_originalStdout = -1;
+    int          m_originalStderr = -1;
+    TempFile     m_stdoutFile;
+    TempFile     m_stderrFile;
+    std::string &m_stdoutDest;
+    std::string &m_stderrDest;
+  };
 
 #endif
 
@@ -11556,133 +12687,133 @@ namespace Catch {
 #include <stdexcept>
 
 #if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
+#if defined(_MSC_VER)
+#include <io.h> //_dup and _dup2
+#define dup _dup
+#define dup2 _dup2
+#define fileno _fileno
+#else
+#include <unistd.h> // dup and dup2
+#endif
 #endif
 
 namespace Catch {
 
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
+  RedirectedStream::RedirectedStream(std::ostream &originalStream, std::ostream &redirectionStream)
+      : m_originalStream(originalStream), m_redirectionStream(redirectionStream),
+        m_prevBuf(m_originalStream.rdbuf())
+  {
+    m_originalStream.rdbuf(m_redirectionStream.rdbuf());
+  }
 
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
+  RedirectedStream::~RedirectedStream() { m_originalStream.rdbuf(m_prevBuf); }
 
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+  RedirectedStdOut::RedirectedStdOut() : m_cout(Catch::cout(), m_rss.get()) {}
+  auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
 
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+  RedirectedStdErr::RedirectedStdErr()
+      : m_cerr(Catch::cerr(), m_rss.get()), m_clog(Catch::clog(), m_rss.get())
+  {
+  }
+  auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
 
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
+  RedirectedStreams::RedirectedStreams(std::string &redirectedCout, std::string &redirectedCerr)
+      : m_redirectedCout(redirectedCout), m_redirectedCerr(redirectedCerr)
+  {
+  }
 
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
+  RedirectedStreams::~RedirectedStreams()
+  {
+    m_redirectedCout += m_redirectedStdOut.str();
+    m_redirectedCerr += m_redirectedStdErr.str();
+  }
 
 #if defined(CATCH_CONFIG_NEW_CAPTURE)
 
 #if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
-            }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
+  TempFile::TempFile()
+  {
+    if (tmpnam_s(m_buffer)) {
+      CATCH_RUNTIME_ERROR("Could not get a temp filename");
+    }
+    if (fopen_s(&m_file, m_buffer, "w")) {
+      char buffer[100];
+      if (strerror_s(buffer, errno)) {
+        CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+      }
+      CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
     }
+  }
 #else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
+  TempFile::TempFile()
+  {
+    m_file = std::tmpfile();
+    if (!m_file) {
+      CATCH_RUNTIME_ERROR("Could not create a temp file.");
     }
+  }
 
 #endif
 
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
+  TempFile::~TempFile()
+  {
+    // TBD: What to do about errors here?
+    std::fclose(m_file);
+    // We manually create the file on Windows only, on Linux
+    // it will be autodeleted
 #if defined(_MSC_VER)
-         std::remove(m_buffer);
+    std::remove(m_buffer);
 #endif
-    }
-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
+  }
 
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
+  FILE *TempFile::getFile() { return m_file; }
 
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
+  std::string TempFile::getContents()
+  {
+    std::stringstream sstr;
+    char              buffer[100] = {};
+    std::rewind(m_file);
+    while (std::fgets(buffer, sizeof(buffer), m_file)) {
+      sstr << buffer;
     }
+    return sstr.str();
+  }
 
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
+  OutputRedirect::OutputRedirect(std::string &stdout_dest, std::string &stderr_dest)
+      : m_originalStdout(dup(1)), m_originalStderr(dup(2)), m_stdoutDest(stdout_dest),
+        m_stderrDest(stderr_dest)
+  {
+    dup2(fileno(m_stdoutFile.getFile()), 1);
+    dup2(fileno(m_stderrFile.getFile()), 2);
+  }
 
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
+  OutputRedirect::~OutputRedirect()
+  {
+    Catch::cout() << std::flush;
+    fflush(stdout);
+    // Since we support overriding these streams, we flush cerr
+    // even though std::cerr is unbuffered
+    Catch::cerr() << std::flush;
+    Catch::clog() << std::flush;
+    fflush(stderr);
+
+    dup2(m_originalStdout, 1);
+    dup2(m_originalStderr, 2);
+
+    m_stdoutDest += m_stdoutFile.getContents();
+    m_stderrDest += m_stderrFile.getContents();
+  }
 
 #endif // CATCH_CONFIG_NEW_CAPTURE
 
 } // namespace Catch
 
 #if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
+#if defined(_MSC_VER)
+#undef dup
+#undef dup2
+#undef fileno
+#endif
 #endif
 // end catch_output_redirect.cpp
 // start catch_polyfills.cpp
@@ -11692,20 +12823,12 @@ namespace Catch {
 namespace Catch {
 
 #if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
+  bool isnan(float f) { return std::isnan(f); }
+  bool isnan(double d) { return std::isnan(d); }
 #else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
+  // For now we only use this for embarcadero
+  bool isnan(float f) { return std::_isnan(f); }
+  bool isnan(double d) { return std::_isnan(d); }
 #endif
 
 } // end namespace Catch
@@ -11714,77 +12837,127 @@ namespace Catch {
 
 namespace Catch {
 
-    std::mt19937& rng() {
-        static std::mt19937 s_rng;
-        return s_rng;
-    }
+  namespace {
 
-    void seedRng( IConfig const& config ) {
-        if( config.rngSeed() != 0 ) {
-            std::srand( config.rngSeed() );
-            rng().seed( config.rngSeed() );
-        }
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4146) // we negate uint32 during the rotate
+#endif
+    // Safe rotr implementation thanks to John Regehr
+    uint32_t rotate_right(uint32_t val, uint32_t count)
+    {
+      const uint32_t mask = 31;
+      count &= mask;
+      return (val >> count) | (val << (-count & mask));
     }
 
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+  } // namespace
+
+  SimplePcg32::SimplePcg32(result_type seed_) { seed(seed_); }
+
+  void SimplePcg32::seed(result_type seed_)
+  {
+    m_state = 0;
+    (*this)();
+    m_state += seed_;
+    (*this)();
+  }
+
+  void SimplePcg32::discard(uint64_t skip)
+  {
+    // We could implement this to run in O(log n) steps, but this
+    // should suffice for our use case.
+    for (uint64_t s = 0; s < skip; ++s) {
+      static_cast<void>((*this)());
     }
-}
+  }
+
+  SimplePcg32::result_type SimplePcg32::operator()()
+  {
+    // prepare the output value
+    const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+    const auto     output     = rotate_right(xorshifted, m_state >> 59u);
+
+    // advance state
+    m_state = m_state * 6364136223846793005ULL + s_inc;
+
+    return output;
+  }
+
+  bool operator==(SimplePcg32 const &lhs, SimplePcg32 const &rhs)
+  {
+    return lhs.m_state == rhs.m_state;
+  }
+
+  bool operator!=(SimplePcg32 const &lhs, SimplePcg32 const &rhs)
+  {
+    return lhs.m_state != rhs.m_state;
+  }
+} // namespace Catch
 // end catch_random_number_generator.cpp
 // start catch_registry_hub.cpp
 
 // start catch_test_case_registry_impl.h
 
-#include <vector>
-#include <set>
 #include <algorithm>
 #include <ios>
+#include <set>
+#include <vector>
 
 namespace Catch {
 
-    class TestCase;
-    struct IConfig;
+  class TestCase;
+  struct IConfig;
 
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+  std::vector<TestCase> sortTests(IConfig const &              config,
+                                  std::vector<TestCase> const &unsortedTestCases);
 
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+  bool isThrowSafe(TestCase const &testCase, IConfig const &config);
+  bool matchTest(TestCase const &testCase, TestSpec const &testSpec, IConfig const &config);
 
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+  void enforceNoDuplicateTestCases(std::vector<TestCase> const &functions);
 
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+  std::vector<TestCase>        filterTests(std::vector<TestCase> const &testCases,
+                                           TestSpec const &testSpec, IConfig const &config);
+  std::vector<TestCase> const &getAllTestCasesSorted(IConfig const &config);
 
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
+  class TestRegistry : public ITestCaseRegistry
+  {
+  public:
+    virtual ~TestRegistry() = default;
 
-        virtual void registerTest( TestCase const& testCase );
+    virtual void registerTest(TestCase const &testCase);
 
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+    std::vector<TestCase> const &getAllTests() const override;
+    std::vector<TestCase> const &getAllTestsSorted(IConfig const &config) const override;
 
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
+  private:
+    std::vector<TestCase>         m_functions;
+    mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+    mutable std::vector<TestCase> m_sortedFunctions;
+    std::size_t                   m_unnamedCount = 0;
+    std::ios_base::Init           m_ostreamInit; // Forces cout/ cerr to be initialised
+  };
 
-    ///////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////
 
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+  class TestInvokerAsFunction : public ITestInvoker
+  {
+    void (*m_testAsFunction)();
 
-        void invoke() const override;
-    };
+  public:
+    TestInvokerAsFunction(void (*testAsFunction)()) noexcept;
 
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+    void invoke() const override;
+  };
 
-    ///////////////////////////////////////////////////////////////////////////
+  std::string extractClassName(StringRef const &classOrQualifiedMethodName);
+
+  ///////////////////////////////////////////////////////////////////////////
 
 } // end namespace Catch
 
@@ -11795,25 +12968,25 @@ namespace Catch {
 
 namespace Catch {
 
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
+  class ReporterRegistry : public IReporterRegistry
+  {
 
-        ~ReporterRegistry() override;
+  public:
+    ~ReporterRegistry() override;
 
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+    IStreamingReporterPtr create(std::string const &name, IConfigPtr const &config) const override;
 
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
+    void registerReporter(std::string const &name, IReporterFactoryPtr const &factory);
+    void registerListener(IReporterFactoryPtr const &factory);
 
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
+    FactoryMap const &getFactories() const override;
+    Listeners const & getListeners() const override;
 
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
+  private:
+    FactoryMap m_factories;
+    Listeners  m_listeners;
+  };
+} // namespace Catch
 
 // end catch_reporter_registry.h
 // start catch_tag_alias_registry.h
@@ -11824,12 +12997,13 @@ namespace Catch {
 
 namespace Catch {
 
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+  struct TagAlias
+  {
+    TagAlias(std::string const &_tag, SourceLineInfo _lineInfo);
 
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
+    std::string    tag;
+    SourceLineInfo lineInfo;
+  };
 
 } // end namespace Catch
 
@@ -11838,34 +13012,37 @@ namespace Catch {
 
 namespace Catch {
 
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+  class TagAliasRegistry : public ITagAliasRegistry
+  {
+  public:
+    ~TagAliasRegistry() override;
+    TagAlias const *find(std::string const &alias) const override;
+    std::string     expandAliases(std::string const &unexpandedTestSpec) const override;
+    void add(std::string const &alias, std::string const &tag, SourceLineInfo const &lineInfo);
 
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
+  private:
+    std::map<std::string, TagAlias> m_registry;
+  };
 
 } // end namespace Catch
 
 // end catch_tag_alias_registry.h
 // start catch_startup_exception_registry.h
 
-#include <vector>
 #include <exception>
+#include <vector>
 
 namespace Catch {
 
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
+  class StartupExceptionRegistry
+  {
+  public:
+    void                                   add(std::exception_ptr const &exception) noexcept;
+    std::vector<std::exception_ptr> const &getExceptions() const noexcept;
+
+  private:
+    std::vector<std::exception_ptr> m_exceptions;
+  };
 
 } // end namespace Catch
 
@@ -11874,110 +13051,112 @@ namespace Catch {
 
 namespace Catch {
 
-    struct ISingleton {
-        virtual ~ISingleton();
-    };
+  struct ISingleton
+  {
+    virtual ~ISingleton();
+  };
 
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
+  void addSingleton(ISingleton *singleton);
+  void cleanupSingletons();
 
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
+  template <typename SingletonImplT, typename InterfaceT = SingletonImplT,
+            typename MutableInterfaceT = InterfaceT>
+  class Singleton : SingletonImplT, public ISingleton
+  {
 
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
+    static auto getInternal() -> Singleton *
+    {
+      static Singleton *s_instance = nullptr;
+      if (!s_instance) {
+        s_instance = new Singleton;
+        addSingleton(s_instance);
+      }
+      return s_instance;
+    }
 
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
+  public:
+    static auto get() -> InterfaceT const & { return *getInternal(); }
+    static auto getMutable() -> MutableInterfaceT & { return *getInternal(); }
+  };
 
 } // namespace Catch
 
 // end catch_singletons.hpp
 namespace Catch {
 
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
+  namespace {
 
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
+    class RegistryHub : public IRegistryHub, public IMutableRegistryHub, private NonCopyable
+    {
 
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
+    public: // IRegistryHub
+      RegistryHub() = default;
+      IReporterRegistry const &getReporterRegistry() const override { return m_reporterRegistry; }
+      ITestCaseRegistry const &getTestCaseRegistry() const override { return m_testCaseRegistry; }
+      IExceptionTranslatorRegistry const &getExceptionTranslatorRegistry() const override
+      {
+        return m_exceptionTranslatorRegistry;
+      }
+      ITagAliasRegistry const &getTagAliasRegistry() const override { return m_tagAliasRegistry; }
+      StartupExceptionRegistry const &getStartupExceptionRegistry() const override
+      {
+        return m_exceptionRegistry;
+      }
+
+    public: // IMutableRegistryHub
+      void registerReporter(std::string const &name, IReporterFactoryPtr const &factory) override
+      {
+        m_reporterRegistry.registerReporter(name, factory);
+      }
+      void registerListener(IReporterFactoryPtr const &factory) override
+      {
+        m_reporterRegistry.registerListener(factory);
+      }
+      void registerTest(TestCase const &testInfo) override
+      {
+        m_testCaseRegistry.registerTest(testInfo);
+      }
+      void registerTranslator(const IExceptionTranslator *translator) override
+      {
+        m_exceptionTranslatorRegistry.registerTranslator(translator);
+      }
+      void registerTagAlias(std::string const &alias, std::string const &tag,
+                            SourceLineInfo const &lineInfo) override
+      {
+        m_tagAliasRegistry.add(alias, tag, lineInfo);
+      }
+      void registerStartupException() noexcept override
+      {
+        m_exceptionRegistry.add(std::current_exception());
+      }
+      IMutableEnumValuesRegistry &getMutableEnumValuesRegistry() override
+      {
+        return m_enumValuesRegistry;
+      }
 
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
+    private:
+      TestRegistry                m_testCaseRegistry;
+      ReporterRegistry            m_reporterRegistry;
+      ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+      TagAliasRegistry            m_tagAliasRegistry;
+      StartupExceptionRegistry    m_exceptionRegistry;
+      Detail::EnumValuesRegistry  m_enumValuesRegistry;
+    };
+  } // namespace
 
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+  using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
 
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
+  IRegistryHub const & getRegistryHub() { return RegistryHubSingleton::get(); }
+  IMutableRegistryHub &getMutableRegistryHub() { return RegistryHubSingleton::getMutable(); }
+  void                 cleanUp()
+  {
+    cleanupSingletons();
+    cleanUpContext();
+  }
+  std::string translateActiveException()
+  {
+    return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+  }
 
 } // end namespace Catch
 // end catch_registry_hub.cpp
@@ -11985,578 +13164,602 @@ namespace Catch {
 
 namespace Catch {
 
-    ReporterRegistry::~ReporterRegistry() = default;
+  ReporterRegistry::~ReporterRegistry() = default;
 
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
+  IStreamingReporterPtr ReporterRegistry::create(std::string const &name,
+                                                 IConfigPtr const & config) const
+  {
+    auto it = m_factories.find(name);
+    if (it == m_factories.end())
+      return nullptr;
+    return it->second->create(ReporterConfig(config));
+  }
 
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
+  void ReporterRegistry::registerReporter(std::string const &        name,
+                                          IReporterFactoryPtr const &factory)
+  {
+    m_factories.emplace(name, factory);
+  }
+  void ReporterRegistry::registerListener(IReporterFactoryPtr const &factory)
+  {
+    m_listeners.push_back(factory);
+  }
 
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
+  IReporterRegistry::FactoryMap const &ReporterRegistry::getFactories() const
+  {
+    return m_factories;
+  }
+  IReporterRegistry::Listeners const &ReporterRegistry::getListeners() const { return m_listeners; }
 
-}
+} // namespace Catch
 // end catch_reporter_registry.cpp
 // start catch_result_type.cpp
 
 namespace Catch {
 
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
+  bool isOk(ResultWas::OfType resultType) { return (resultType & ResultWas::FailureBit) == 0; }
+  bool isJustInfo(int flags) { return flags == ResultWas::Info; }
 
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
+  ResultDisposition::Flags operator|(ResultDisposition::Flags lhs, ResultDisposition::Flags rhs)
+  {
+    return static_cast<ResultDisposition::Flags>(static_cast<int>(lhs) | static_cast<int>(rhs));
+  }
 
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+  bool shouldContinueOnFailure(int flags)
+  {
+    return (flags & ResultDisposition::ContinueOnFailure) != 0;
+  }
+  bool shouldSuppressFailure(int flags) { return (flags & ResultDisposition::SuppressFail) != 0; }
 
 } // end namespace Catch
 // end catch_result_type.cpp
 // start catch_run_context.cpp
 
-#include <cassert>
 #include <algorithm>
+#include <cassert>
 #include <sstream>
 
 namespace Catch {
 
-    namespace Generators {
-        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            GeneratorBasePtr m_generator;
+  namespace Generators {
+    struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker
+    {
+      GeneratorBasePtr m_generator;
+
+      GeneratorTracker(TestCaseTracking::NameAndLocation const &nameAndLocation,
+                       TrackerContext &ctx, ITracker *parent)
+          : TrackerBase(nameAndLocation, ctx, parent)
+      {
+      }
+      ~GeneratorTracker();
+
+      static GeneratorTracker &acquire(TrackerContext &                         ctx,
+                                       TestCaseTracking::NameAndLocation const &nameAndLocation)
+      {
+        std::shared_ptr<GeneratorTracker> tracker;
+
+        ITracker &currentTracker = ctx.currentTracker();
+        if (TestCaseTracking::ITrackerPtr childTracker =
+                currentTracker.findChild(nameAndLocation)) {
+          assert(childTracker);
+          assert(childTracker->isGeneratorTracker());
+          tracker = std::static_pointer_cast<GeneratorTracker>(childTracker);
+        }
+        else {
+          tracker = std::make_shared<GeneratorTracker>(nameAndLocation, ctx, &currentTracker);
+          currentTracker.addChild(tracker);
+        }
 
-            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-            :   TrackerBase( nameAndLocation, ctx, parent )
-            {}
-            ~GeneratorTracker();
+        if (!ctx.completedCycle() && !tracker->isComplete()) {
+          tracker->open();
+        }
 
-            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
-                std::shared_ptr<GeneratorTracker> tracker;
+        return *tracker;
+      }
 
-                ITracker& currentTracker = ctx.currentTracker();
-                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                    assert( childTracker );
-                    assert( childTracker->isGeneratorTracker() );
-                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
-                }
-                else {
-                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
-                    currentTracker.addChild( tracker );
-                }
+      // TrackerBase interface
+      bool isGeneratorTracker() const override { return true; }
+      auto hasGenerator() const -> bool override { return !!m_generator; }
+      void close() override
+      {
+        TrackerBase::close();
+        // Generator interface only finds out if it has another item on atual move
+        if (m_runState == CompletedSuccessfully && m_generator->next()) {
+          m_children.clear();
+          m_runState = Executing;
+        }
+      }
 
-                if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    tracker->open();
-                }
+      // IGeneratorTracker interface
+      auto getGenerator() const -> GeneratorBasePtr const & override { return m_generator; }
+      void setGenerator(GeneratorBasePtr &&generator) override
+      {
+        m_generator = std::move(generator);
+      }
+    };
+    GeneratorTracker::~GeneratorTracker() {}
+  } // namespace Generators
+
+  RunContext::RunContext(IConfigPtr const &_config, IStreamingReporterPtr &&reporter)
+      : m_runInfo(_config->name()), m_context(getCurrentMutableContext()), m_config(_config),
+        m_reporter(std::move(reporter)), m_lastAssertionInfo{StringRef(), SourceLineInfo("", 0),
+                                                             StringRef(),
+                                                             ResultDisposition::Normal},
+        m_includeSuccessfulResults(m_config->includeSuccessfulResults() ||
+                                   m_reporter->getPreferences().shouldReportAllAssertions)
+  {
+    m_context.setRunner(this);
+    m_context.setConfig(m_config);
+    m_context.setResultCapture(this);
+    m_reporter->testRunStarting(m_runInfo);
+  }
 
-                return *tracker;
-            }
+  RunContext::~RunContext()
+  {
+    m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+  }
 
-            // TrackerBase interface
-            bool isGeneratorTracker() const override { return true; }
-            auto hasGenerator() const -> bool override {
-                return !!m_generator;
-            }
-            void close() override {
-                TrackerBase::close();
-                // Generator interface only finds out if it has another item on atual move
-                if (m_runState == CompletedSuccessfully && m_generator->next()) {
-                    m_children.clear();
-                    m_runState = Executing;
-                }
-            }
+  void RunContext::testGroupStarting(std::string const &testSpec, std::size_t groupIndex,
+                                     std::size_t groupsCount)
+  {
+    m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+  }
 
-            // IGeneratorTracker interface
-            auto getGenerator() const -> GeneratorBasePtr const& override {
-                return m_generator;
-            }
-            void setGenerator( GeneratorBasePtr&& generator ) override {
-                m_generator = std::move( generator );
-            }
-        };
-        GeneratorTracker::~GeneratorTracker() {}
-    }
+  void RunContext::testGroupEnded(std::string const &testSpec, Totals const &totals,
+                                  std::size_t groupIndex, std::size_t groupsCount)
+  {
+    m_reporter->testGroupEnded(
+        TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+  }
 
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
+  Totals RunContext::runTest(TestCase const &testCase)
+  {
+    Totals prevTotals = m_totals;
 
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
+    std::string redirectedCout;
+    std::string redirectedCerr;
 
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
+    auto const &testInfo = testCase.getTestCaseInfo();
 
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
+    m_reporter->testCaseStarting(testInfo);
 
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
+    m_activeTestCase = &testCase;
 
-        std::string redirectedCout;
-        std::string redirectedCerr;
+    ITracker &rootTracker = m_trackerContext.startRun();
+    assert(rootTracker.isSectionTracker());
+    static_cast<SectionTracker &>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+    do {
+      m_trackerContext.startCycle();
+      m_testCaseTracker = &SectionTracker::acquire(
+          m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+      runCurrentTest(redirectedCout, redirectedCerr);
+    } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
 
-        auto const& testInfo = testCase.getTestCaseInfo();
+    Totals deltaTotals = m_totals.delta(prevTotals);
+    if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+      deltaTotals.assertions.failed++;
+      deltaTotals.testCases.passed--;
+      deltaTotals.testCases.failed++;
+    }
+    m_totals.testCases += deltaTotals.testCases;
+    m_reporter->testCaseEnded(
+        TestCaseStats(testInfo, deltaTotals, redirectedCout, redirectedCerr, aborting()));
 
-        m_reporter->testCaseStarting(testInfo);
+    m_activeTestCase  = nullptr;
+    m_testCaseTracker = nullptr;
 
-        m_activeTestCase = &testCase;
+    return deltaTotals;
+  }
 
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
+  IConfigPtr RunContext::config() const { return m_config; }
 
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
+  IStreamingReporter &RunContext::reporter() const { return *m_reporter; }
 
-        return deltaTotals;
+  void RunContext::assertionEnded(AssertionResult const &result)
+  {
+    if (result.getResultType() == ResultWas::Ok) {
+      m_totals.assertions.passed++;
+      m_lastAssertionPassed = true;
     }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
+    else if (!result.isOk()) {
+      m_lastAssertionPassed = false;
+      if (m_activeTestCase->getTestCaseInfo().okToFail())
+        m_totals.assertions.failedButOk++;
+      else
+        m_totals.assertions.failed++;
     }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
+    else {
+      m_lastAssertionPassed = true;
     }
 
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (!result.isOk()) {
-            m_lastAssertionPassed = false;
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        if (result.getResultType() != ResultWas::Warning)
-            m_messageScopes.clear();
+    // We have no use for the return value (whether messages should be cleared), because messages
+    // were made scoped and should be let to clear themselves out.
+    static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
 
-        // Reset working state
-        resetAssertionInfo();
-        m_lastResult = result;
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-    }
+    if (result.getResultType() != ResultWas::Warning)
+      m_messageScopes.clear();
 
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
+    // Reset working state
+    resetAssertionInfo();
+    m_lastResult = result;
+  }
+  void RunContext::resetAssertionInfo()
+  {
+    m_lastAssertionInfo.macroName          = StringRef();
+    m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+  }
 
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+  bool RunContext::sectionStarted(SectionInfo const &sectionInfo, Counts &assertions)
+  {
+    ITracker &sectionTracker = SectionTracker::acquire(
+        m_trackerContext,
+        TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+    if (!sectionTracker.isOpen())
+      return false;
+    m_activeSections.push_back(&sectionTracker);
 
-        m_reporter->sectionStarting(sectionInfo);
+    m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
 
-        assertions = m_totals.assertions;
+    m_reporter->sectionStarting(sectionInfo);
 
-        return true;
-    }
-    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        using namespace Generators;
-        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
-        assert( tracker.isOpen() );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
+    assertions = m_totals.assertions;
 
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
+    return true;
+  }
+  auto RunContext::acquireGeneratorTracker(SourceLineInfo const &lineInfo) -> IGeneratorTracker &
+  {
+    using namespace Generators;
+    GeneratorTracker &tracker = GeneratorTracker::acquire(
+        m_trackerContext, TestCaseTracking::NameAndLocation("generator", lineInfo));
+    assert(tracker.isOpen());
+    m_lastAssertionInfo.lineInfo = lineInfo;
+    return tracker;
+  }
 
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
+  bool RunContext::testForMissingAssertions(Counts &assertions)
+  {
+    if (assertions.total() != 0)
+      return false;
+    if (!m_config->warnAboutMissingAssertions())
+      return false;
+    if (m_trackerContext.currentTracker().hasChildren())
+      return false;
+    m_totals.assertions.failed++;
+    assertions.failed++;
+    return true;
+  }
 
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
+  void RunContext::sectionEnded(SectionEndInfo const &endInfo)
+  {
+    Counts assertions        = m_totals.assertions - endInfo.prevAssertions;
+    bool   missingAssertions = testForMissingAssertions(assertions);
 
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
+    if (!m_activeSections.empty()) {
+      m_activeSections.back()->close();
+      m_activeSections.pop_back();
     }
 
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
+    m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions,
+                                          endInfo.durationInSeconds, missingAssertions));
+    m_messages.clear();
+    m_messageScopes.clear();
+  }
 
-        m_unfinishedSections.push_back(endInfo);
-    }
+  void RunContext::sectionEndedEarly(SectionEndInfo const &endInfo)
+  {
+    if (m_unfinishedSections.empty())
+      m_activeSections.back()->fail();
+    else
+      m_activeSections.back()->close();
+    m_activeSections.pop_back();
+
+    m_unfinishedSections.push_back(endInfo);
+  }
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void RunContext::benchmarkPreparing(std::string const& name) {
-		m_reporter->benchmarkPreparing(name);
-	}
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-	void RunContext::benchmarkFailed(std::string const & error) {
-		m_reporter->benchmarkFailed(error);
-	}
+  void RunContext::benchmarkPreparing(std::string const &name)
+  {
+    m_reporter->benchmarkPreparing(name);
+  }
+  void RunContext::benchmarkStarting(BenchmarkInfo const &info)
+  {
+    m_reporter->benchmarkStarting(info);
+  }
+  void RunContext::benchmarkEnded(BenchmarkStats<> const &stats)
+  {
+    m_reporter->benchmarkEnded(stats);
+  }
+  void RunContext::benchmarkFailed(std::string const &error) { m_reporter->benchmarkFailed(error); }
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
-        m_messageScopes.emplace_back( builder );
-    }
+  void RunContext::pushScopedMessage(MessageInfo const &message) { m_messages.push_back(message); }
 
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
+  void RunContext::popScopedMessage(MessageInfo const &message)
+  {
+    m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+  }
 
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
+  void RunContext::emplaceUnscopedMessage(MessageBuilder const &builder)
+  {
+    m_messageScopes.emplace_back(builder);
+  }
 
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
+  std::string RunContext::getCurrentTestName() const
+  {
+    return m_activeTestCase ? m_activeTestCase->getTestCaseInfo().name : std::string();
+  }
 
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
+  const AssertionResult *RunContext::getLastResult() const { return &(*m_lastResult); }
 
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = message;
-        AssertionResult result(m_lastAssertionInfo, tempResult);
+  void RunContext::exceptionEarlyReported() { m_shouldReportUnexpected = false; }
 
-        assertionEnded(result);
+  void RunContext::handleFatalErrorCondition(StringRef message)
+  {
+    // First notify reporter that bad things happened
+    m_reporter->fatalErrorEncountered(message);
 
-        handleUnfinishedSections();
+    // Don't rebuild the result -- the stringification itself can cause more fatal errors
+    // Instead, fake a result data.
+    AssertionResultData tempResult(ResultWas::FatalErrorCondition, {false});
+    tempResult.message = static_cast<std::string>(message);
+    AssertionResult result(m_lastAssertionInfo, tempResult);
 
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+    assertionEnded(result);
 
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
+    handleUnfinishedSections();
 
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+    // Recreate section for test case (as we will lose the one that was in scope)
+    auto const &testCaseInfo = m_activeTestCase->getTestCaseInfo();
+    SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
 
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
+    Counts assertions;
+    assertions.failed = 1;
+    SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+    m_reporter->sectionEnded(testCaseSectionStats);
 
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
+    auto const &testInfo = m_activeTestCase->getTestCaseInfo();
 
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
+    Totals deltaTotals;
+    deltaTotals.testCases.failed  = 1;
+    deltaTotals.assertions.failed = 1;
+    m_reporter->testCaseEnded(
+        TestCaseStats(testInfo, deltaTotals, std::string(), std::string(), false));
+    m_totals.testCases.failed++;
+    testGroupEnded(std::string(), m_totals, 1, 1);
+    m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+  }
 
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
+  bool RunContext::lastAssertionPassed() { return m_lastAssertionPassed; }
 
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+  void RunContext::assertionPassed()
+  {
+    m_lastAssertionPassed = true;
+    ++m_totals.assertions.passed;
+    resetAssertionInfo();
+    m_messageScopes.clear();
+  }
 
-        seedRng(*m_config);
+  bool RunContext::aborting() const
+  {
+    return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+  }
 
-        Timer timer;
-        CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+  void RunContext::runCurrentTest(std::string &redirectedCout, std::string &redirectedCerr)
+  {
+    auto const &testCaseInfo = m_activeTestCase->getTestCaseInfo();
+    SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+    m_reporter->sectionStarting(testCaseSection);
+    Counts prevAssertions    = m_totals.assertions;
+    double duration          = 0;
+    m_shouldReportUnexpected = true;
+    m_lastAssertionInfo      = {"TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(),
+                           ResultDisposition::Normal};
+
+    seedRng(*m_config);
+
+    Timer timer;
+    CATCH_TRY
+    {
+      if (m_reporter->getPreferences().shouldRedirectStdOut) {
 #if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+        RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
 
-                timer.start();
-                invokeActiveTestCase();
+        timer.start();
+        invokeActiveTestCase();
 #else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
+        OutputRedirect r(redirectedCout, redirectedCerr);
+        timer.start();
+        invokeActiveTestCase();
 #endif
-            } else {
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
+      }
+      else {
+        timer.start();
+        invokeActiveTestCase();
+      }
+      duration = timer.getElapsedSeconds();
+    }
+    CATCH_CATCH_ANON(TestFailureException &)
+    {
+      // This just means the test was aborted due to failure
     }
+    CATCH_CATCH_ALL
+    {
+      // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+      // are reported without translation at the point of origin.
+      if (m_shouldReportUnexpected) {
+        AssertionReaction dummyReaction;
+        handleUnexpectedInflightException(m_lastAssertionInfo, translateActiveException(),
+                                          dummyReaction);
+      }
+    }
+    Counts assertions        = m_totals.assertions - prevAssertions;
+    bool   missingAssertions = testForMissingAssertions(assertions);
+
+    m_testCaseTracker->close();
+    handleUnfinishedSections();
+    m_messages.clear();
+    m_messageScopes.clear();
+
+    SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+    m_reporter->sectionEnded(testCaseSectionStats);
+  }
 
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
+  void RunContext::invokeActiveTestCase()
+  {
+    FatalConditionHandler fatalConditionHandler; // Handle signals
+    m_activeTestCase->invoke();
+    fatalConditionHandler.reset();
+  }
 
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
+  void RunContext::handleUnfinishedSections()
+  {
+    // If sections ended prematurely due to an exception we stored their
+    // infos here so we can tear them down outside the unwind process.
+    for (auto it = m_unfinishedSections.rbegin(), itEnd = m_unfinishedSections.rend(); it != itEnd;
+         ++it)
+      sectionEnded(*it);
+    m_unfinishedSections.clear();
+  }
 
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
+  void RunContext::handleExpr(AssertionInfo const &info, ITransientExpression const &expr,
+                              AssertionReaction &reaction)
+  {
+    m_reporter->assertionStarting(info);
 
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
+    bool negated = isFalseTest(info.resultDisposition);
+    bool result  = expr.getResult() != negated;
 
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
+    if (result) {
+      if (!m_includeSuccessfulResults) {
+        assertionPassed();
+      }
+      else {
+        reportExpr(info, ResultWas::Ok, &expr, negated);
+      }
     }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
+    else {
+      reportExpr(info, ResultWas::ExpressionFailed, &expr, negated);
+      populateReaction(reaction);
+    }
+  }
+  void RunContext::reportExpr(AssertionInfo const &info, ResultWas::OfType resultType,
+                              ITransientExpression const *expr, bool negated)
+  {
 
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
+    m_lastAssertionInfo = info;
+    AssertionResultData data(resultType, LazyExpression(negated));
 
-        AssertionResult assertionResult{ info, data };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+    AssertionResult assertionResult{info, data};
+    assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
 
-        assertionEnded( assertionResult );
-    }
+    assertionEnded(assertionResult);
+  }
 
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            StringRef const& message,
-            AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
+  void RunContext::handleMessage(AssertionInfo const &info, ResultWas::OfType resultType,
+                                 StringRef const &message, AssertionReaction &reaction)
+  {
+    m_reporter->assertionStarting(info);
 
-        m_lastAssertionInfo = info;
+    m_lastAssertionInfo = info;
 
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ m_lastAssertionInfo, data };
-        assertionEnded( assertionResult );
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
+    AssertionResultData data(resultType, LazyExpression(false));
+    data.message = static_cast<std::string>(message);
+    AssertionResult assertionResult{m_lastAssertionInfo, data};
+    assertionEnded(assertionResult);
+    if (!assertionResult.isOk())
+      populateReaction(reaction);
+  }
+  void RunContext::handleUnexpectedExceptionNotThrown(AssertionInfo const &info,
+                                                      AssertionReaction &  reaction)
+  {
+    handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+  }
 
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string const& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
+  void RunContext::handleUnexpectedInflightException(AssertionInfo const &info,
+                                                     std::string const &  message,
+                                                     AssertionReaction &  reaction)
+  {
+    m_lastAssertionInfo = info;
+
+    AssertionResultData data(ResultWas::ThrewException, LazyExpression(false));
+    data.message = message;
+    AssertionResult assertionResult{info, data};
+    assertionEnded(assertionResult);
+    populateReaction(reaction);
+  }
 
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-        populateReaction( reaction );
-    }
+  void RunContext::populateReaction(AssertionReaction &reaction)
+  {
+    reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+    reaction.shouldThrow =
+        aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+  }
 
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
+  void RunContext::handleIncomplete(AssertionInfo const &info)
+  {
+    m_lastAssertionInfo = info;
 
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        m_lastAssertionInfo = info;
+    AssertionResultData data(ResultWas::ThrewException, LazyExpression(false));
+    data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+    AssertionResult assertionResult{info, data};
+    assertionEnded(assertionResult);
+  }
+  void RunContext::handleNonExpr(AssertionInfo const &info, ResultWas::OfType resultType,
+                                 AssertionReaction &reaction)
+  {
+    m_lastAssertionInfo = info;
 
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
+    AssertionResultData data(resultType, LazyExpression(false));
+    AssertionResult     assertionResult{info, data};
+    assertionEnded(assertionResult);
 
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
+    if (!assertionResult.isOk())
+      populateReaction(reaction);
+  }
 
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
+  IResultCapture &getResultCapture()
+  {
+    if (auto *capture = getCurrentContext().getResultCapture())
+      return *capture;
+    else
+      CATCH_INTERNAL_ERROR("No result capture instance");
+  }
 
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
+  void seedRng(IConfig const &config)
+  {
+    if (config.rngSeed() != 0) {
+      std::srand(config.rngSeed());
+      rng().seed(config.rngSeed());
     }
-}
+  }
+
+  unsigned int rngSeed() { return getCurrentContext().getConfig()->rngSeed(); }
+
+} // namespace Catch
 // end catch_run_context.cpp
 // start catch_section.cpp
 
 namespace Catch {
 
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
+  Section::Section(SectionInfo const &info)
+      : m_info(info), m_sectionIncluded(getResultCapture().sectionStarted(m_info, m_assertions))
+  {
+    m_timer.start();
+  }
 
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
-            if( uncaught_exceptions() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
+  Section::~Section()
+  {
+    if (m_sectionIncluded) {
+      SectionEndInfo endInfo{m_info, m_assertions, m_timer.getElapsedSeconds()};
+      if (uncaught_exceptions())
+        getResultCapture().sectionEndedEarly(endInfo);
+      else
+        getResultCapture().sectionEnded(endInfo);
     }
+  }
 
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
+  // This indicates whether the section should be executed or not
+  Section::operator bool() const { return m_sectionIncluded; }
 
 } // end namespace Catch
 // end catch_section.cpp
@@ -12564,12 +13767,10 @@ namespace Catch {
 
 namespace Catch {
 
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name )
-    :   name( _name ),
-        lineInfo( _lineInfo )
-    {}
+  SectionInfo::SectionInfo(SourceLineInfo const &_lineInfo, std::string const &_name)
+      : name(_name), lineInfo(_lineInfo)
+  {
+  }
 
 } // end namespace Catch
 // end catch_section_info.cpp
@@ -12581,46 +13782,47 @@ namespace Catch {
 
 namespace Catch {
 
-    class Session : NonCopyable {
-    public:
+  class Session : NonCopyable
+  {
+  public:
+    Session();
+    ~Session() override;
 
-        Session();
-        ~Session() override;
+    void showHelp() const;
+    void libIdentify();
 
-        void showHelp() const;
-        void libIdentify();
+    int applyCommandLine(int argc, char const *const *argv);
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int applyCommandLine(int argc, wchar_t const *const *argv);
+#endif
 
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
+    void useConfigData(ConfigData const &configData);
 
-        void useConfigData( ConfigData const& configData );
+    template <typename CharT> int run(int argc, CharT const *const argv[])
+    {
+      if (m_startupExceptions)
+        return 1;
+      int returnCode = applyCommandLine(argc, argv);
+      if (returnCode == 0)
+        returnCode = run();
+      return returnCode;
+    }
 
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
+    int run();
 
-        int run();
+    clara::Parser const &cli() const;
+    void                 cli(clara::Parser const &newParser);
+    ConfigData &         configData();
+    Config &             config();
 
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
+  private:
+    int runInternal();
 
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
+    clara::Parser           m_cli;
+    ConfigData              m_configData;
+    std::shared_ptr<Config> m_config;
+    bool                    m_startupExceptions = false;
+  };
 
 } // end namespace Catch
 
@@ -12631,309 +13833,325 @@ namespace Catch {
 
 namespace Catch {
 
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
+  // Versioning information
+  struct Version
+  {
+    Version(Version const &) = delete;
+    Version &operator=(Version const &) = delete;
+    Version(unsigned int _majorVersion, unsigned int _minorVersion, unsigned int _patchNumber,
+            char const *const _branchName, unsigned int _buildNumber);
 
-    Version const& libraryVersion();
-}
+    unsigned int const majorVersion;
+    unsigned int const minorVersion;
+    unsigned int const patchNumber;
+
+    // buildNumber is only used if branchName is not null
+    char const *const  branchName;
+    unsigned int const buildNumber;
+
+    friend std::ostream &operator<<(std::ostream &os, Version const &version);
+  };
+
+  Version const &libraryVersion();
+} // namespace Catch
 
 // end catch_version.h
 #include <cstdlib>
 #include <iomanip>
-#include <set>
 #include <iterator>
+#include <set>
 
 namespace Catch {
 
-    namespace {
-        const int MaxExitCode = 255;
-
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+  namespace {
+    const int MaxExitCode = 255;
 
-            return reporter;
-        }
+    IStreamingReporterPtr createReporter(std::string const &reporterName, IConfigPtr const &config)
+    {
+      auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+      CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
 
-        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
-            }
+      return reporter;
+    }
 
-            // On older platforms, returning std::unique_ptr<ListeningReporter>
-            // when the return type is std::unique_ptr<IStreamingReporter>
-            // doesn't compile without a std::move call. However, this causes
-            // a warning on newer platforms. Thus, we have to work around
-            // it a bit and downcast the pointer manually.
-            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
-            auto& multi = static_cast<ListeningReporter&>(*ret);
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi.addListener(listener->create(Catch::ReporterConfig(config)));
-            }
-            multi.addReporter(createReporter(config->getReporterName(), config));
-            return ret;
+    IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const &config)
+    {
+      if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+        return createReporter(config->getReporterName(), config);
+      }
+
+      // On older platforms, returning std::unique_ptr<ListeningReporter>
+      // when the return type is std::unique_ptr<IStreamingReporter>
+      // doesn't compile without a std::move call. However, this causes
+      // a warning on newer platforms. Thus, we have to work around
+      // it a bit and downcast the pointer manually.
+      auto        ret       = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+      auto &      multi     = static_cast<ListeningReporter &>(*ret);
+      auto const &listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+      for (auto const &listener : listeners) {
+        multi.addListener(listener->create(Catch::ReporterConfig(config)));
+      }
+      multi.addReporter(createReporter(config->getReporterName(), config));
+      return ret;
+    }
+
+    class TestGroup
+    {
+    public:
+      explicit TestGroup(std::shared_ptr<Config> const &config)
+          : m_config{config}, m_context{config, makeReporter(config)}
+      {
+        auto const &allTestCases = getAllTestCasesSorted(*m_config);
+        m_matches                = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+        auto const &invalidArgs  = m_config->testSpec().getInvalidArgs();
+
+        if (m_matches.empty() && invalidArgs.empty()) {
+          for (auto const &test : allTestCases)
+            if (!test.isHidden())
+              m_tests.emplace(&test);
         }
+        else {
+          for (auto const &match : m_matches)
+            m_tests.insert(match.tests.begin(), match.tests.end());
+        }
+      }
 
-        class TestGroup {
-        public:
-            explicit TestGroup(std::shared_ptr<Config> const& config)
-            : m_config{config}
-            , m_context{config, makeReporter(config)}
-            {
-                auto const& allTestCases = getAllTestCasesSorted(*m_config);
-                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
-
-                if (m_matches.empty()) {
-                    for (auto const& test : allTestCases)
-                        if (!test.isHidden())
-                            m_tests.emplace(&test);
-                } else {
-                    for (auto const& match : m_matches)
-                        m_tests.insert(match.tests.begin(), match.tests.end());
-                }
-            }
-
-            Totals execute() {
-                Totals totals;
-                m_context.testGroupStarting(m_config->name(), 1, 1);
-                for (auto const& testCase : m_tests) {
-                    if (!m_context.aborting())
-                        totals += m_context.runTest(*testCase);
-                    else
-                        m_context.reporter().skipTest(*testCase);
-                }
-
-                for (auto const& match : m_matches) {
-                    if (match.tests.empty()) {
-                        m_context.reporter().noMatchingTestCases(match.name);
-                        totals.error = -1;
-                    }
-                }
-                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
-                return totals;
-            }
-
-        private:
-            using Tests = std::set<TestCase const*>;
+      Totals execute()
+      {
+        auto const &invalidArgs = m_config->testSpec().getInvalidArgs();
+        Totals      totals;
+        m_context.testGroupStarting(m_config->name(), 1, 1);
+        for (auto const &testCase : m_tests) {
+          if (!m_context.aborting())
+            totals += m_context.runTest(*testCase);
+          else
+            m_context.reporter().skipTest(*testCase);
+        }
 
-            std::shared_ptr<Config> m_config;
-            RunContext m_context;
-            Tests m_tests;
-            TestSpec::Matches m_matches;
-        };
+        for (auto const &match : m_matches) {
+          if (match.tests.empty()) {
+            m_context.reporter().noMatchingTestCases(match.name);
+            totals.error = -1;
+          }
+        }
 
-        void applyFilenamesAsTags(Catch::IConfig const& config) {
-            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-            for (auto& testCase : tests) {
-                auto tags = testCase.tags;
+        if (!invalidArgs.empty()) {
+          for (auto const &invalidArg : invalidArgs)
+            m_context.reporter().reportInvalidArguments(invalidArg);
+        }
 
-                std::string filename = testCase.lineInfo.file;
-                auto lastSlash = filename.find_last_of("\\/");
-                if (lastSlash != std::string::npos) {
-                    filename.erase(0, lastSlash);
-                    filename[0] = '#';
-                }
+        m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+        return totals;
+      }
 
-                auto lastDot = filename.find_last_of('.');
-                if (lastDot != std::string::npos) {
-                    filename.erase(lastDot);
-                }
+    private:
+      using Tests = std::set<TestCase const *>;
 
-                tags.push_back(std::move(filename));
-                setTags(testCase, tags);
-            }
-        }
+      std::shared_ptr<Config> m_config;
+      RunContext              m_context;
+      Tests                   m_tests;
+      TestSpec::Matches       m_matches;
+    };
 
-    } // anon namespace
+    void applyFilenamesAsTags(Catch::IConfig const &config)
+    {
+      auto &tests = const_cast<std::vector<TestCase> &>(getAllTestCasesSorted(config));
+      for (auto &testCase : tests) {
+        auto tags = testCase.tags;
 
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+        std::string filename  = testCase.lineInfo.file;
+        auto        lastSlash = filename.find_last_of("\\/");
+        if (lastSlash != std::string::npos) {
+          filename.erase(0, lastSlash);
+          filename[0] = '#';
         }
 
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
+        auto lastDot = filename.find_last_of('.');
+        if (lastDot != std::string::npos) {
+          filename.erase(lastDot);
         }
-#endif
 
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
+        tags.push_back(std::move(filename));
+        setTags(testCase, tags);
+      }
     }
 
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
+  } // namespace
 
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if( m_startupExceptions )
-            return 1;
+  Session::Session()
+  {
+    static bool alreadyInstantiated = false;
+    if (alreadyInstantiated) {
+      CATCH_TRY { CATCH_INTERNAL_ERROR("Only one instance of Catch::Session can ever be used"); }
+      CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+    }
 
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
+    // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    const auto &exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+    if (!exceptions.empty()) {
+      config();
+      getCurrentMutableContext().setConfig(m_config);
+
+      m_startupExceptions = true;
+      Colour colourGuard(Colour::Red);
+      Catch::cerr() << "Errors occurred during startup!" << '\n';
+      // iterate over all exceptions and notify user
+      for (const auto &ex_ptr : exceptions) {
+        try {
+          std::rethrow_exception(ex_ptr);
         }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
+        catch (std::exception const &ex) {
+          Catch::cerr() << Column(ex.what()).indent(2) << '\n';
+        }
+      }
     }
+#endif
 
-#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+    alreadyInstantiated = true;
+    m_cli               = makeCommandLineParser(m_configData);
+  }
+  Session::~Session() { Catch::cleanUp(); }
+
+  void Session::showHelp() const
+  {
+    Catch::cout() << "\nCatch v" << libraryVersion() << "\n"
+                  << m_cli << std::endl
+                  << "For more detailed usage please see the project docs\n"
+                  << std::endl;
+  }
+  void Session::libIdentify()
+  {
+    Catch::cout() << std::left << std::setw(16) << "description: "
+                  << "A Catch2 test executable\n"
+                  << std::left << std::setw(16) << "category: "
+                  << "testframework\n"
+                  << std::left << std::setw(16) << "framework: "
+                  << "Catch Test\n"
+                  << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+  }
+
+  int Session::applyCommandLine(int argc, char const *const *argv)
+  {
+    if (m_startupExceptions)
+      return 1;
+
+    auto result = m_cli.parse(clara::Args(argc, argv));
+    if (!result) {
+      config();
+      getCurrentMutableContext().setConfig(m_config);
+      Catch::cerr() << Colour(Colour::Red) << "\nError(s) in input:\n"
+                    << Column(result.errorMessage()).indent(2) << "\n\n";
+      Catch::cerr() << "Run with -? for usage\n" << std::endl;
+      return MaxExitCode;
+    }
+
+    if (m_configData.showHelp)
+      showHelp();
+    if (m_configData.libIdentify)
+      libIdentify();
+    m_config.reset();
+    return 0;
+  }
 
-        char **utf8Argv = new char *[ argc ];
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+  int Session::applyCommandLine(int argc, wchar_t const *const *argv)
+  {
 
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+    char **utf8Argv = new char *[argc];
 
-            utf8Argv[ i ] = new char[ bufSize ];
+    for (int i = 0; i < argc; ++i) {
+      int bufSize = WideCharToMultiByte(CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL);
 
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
-        }
+      utf8Argv[i] = new char[bufSize];
 
-        int returnCode = applyCommandLine( argc, utf8Argv );
+      WideCharToMultiByte(CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL);
+    }
 
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
+    int returnCode = applyCommandLine(argc, utf8Argv);
 
-        delete [] utf8Argv;
+    for (int i = 0; i < argc; ++i)
+      delete[] utf8Argv[i];
 
-        return returnCode;
-    }
-#endif
+    delete[] utf8Argv;
 
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
+    return returnCode;
+  }
+#endif
 
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
+  void Session::useConfigData(ConfigData const &configData)
+  {
+    m_configData = configData;
+    m_config.reset();
+  }
 
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
+  int Session::run()
+  {
+    if ((m_configData.waitForKeypress & WaitForKeypress::BeforeStart) != 0) {
+      Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+      static_cast<void>(std::getchar());
     }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
+    int exitCode = runInternal();
+    if ((m_configData.waitForKeypress & WaitForKeypress::BeforeExit) != 0) {
+      Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode
+                    << std::endl;
+      static_cast<void>(std::getchar());
     }
+    return exitCode;
+  }
 
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
+  clara::Parser const &Session::cli() const { return m_cli; }
+  void                 Session::cli(clara::Parser const &newParser) { m_cli = newParser; }
+  ConfigData &         Session::configData() { return m_configData; }
+  Config &             Session::config()
+  {
+    if (!m_config)
+      m_config = std::make_shared<Config>(m_configData);
+    return *m_config;
+  }
 
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
+  int Session::runInternal()
+  {
+    if (m_startupExceptions)
+      return 1;
 
-        CATCH_TRY {
-            config(); // Force config to be constructed
+    if (m_configData.showHelp || m_configData.libIdentify) {
+      return 0;
+    }
+
+    CATCH_TRY
+    {
+      config(); // Force config to be constructed
 
-            seedRng( *m_config );
+      seedRng(*m_config);
 
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
+      if (m_configData.filenamesAsTags)
+        applyFilenamesAsTags(*m_config);
 
-            // Handle list request
-            if( Option<std::size_t> listed = list( m_config ) )
-                return static_cast<int>( *listed );
+      // Handle list request
+      if (Option<std::size_t> listed = list(m_config))
+        return static_cast<int>(*listed);
 
-            TestGroup tests { m_config };
-            auto const totals = tests.execute();
+      TestGroup  tests{m_config};
+      auto const totals = tests.execute();
 
-            if( m_config->warnAboutNoTests() && totals.error == -1 )
-                return 2;
+      if (m_config->warnAboutNoTests() && totals.error == -1)
+        return 2;
 
-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
-        }
+      // Note that on unices only the lower 8 bits are usually used, clamping
+      // the return value to 255 prevents false negative when some multiple
+      // of 256 tests has failed
+      return (std::min)(MaxExitCode,
+                        (std::max)(totals.error, static_cast<int>(totals.assertions.failed)));
+    }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-#endif
+    catch (std::exception &ex)
+    {
+      Catch::cerr() << ex.what() << std::endl;
+      return MaxExitCode;
     }
+#endif
+  }
 
 } // end namespace Catch
 // end catch_session.cpp
@@ -12943,450 +14161,445 @@ namespace Catch {
 
 namespace Catch {
 
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() {}
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
+  namespace {
+    static auto getSingletons() -> std::vector<ISingleton *> *&
+    {
+      static std::vector<ISingleton *> *g_singletons = nullptr;
+      if (!g_singletons)
+        g_singletons = new std::vector<ISingleton *>();
+      return g_singletons;
+    }
+  } // namespace
+
+  ISingleton::~ISingleton() {}
+
+  void addSingleton(ISingleton *singleton) { getSingletons()->push_back(singleton); }
+  void cleanupSingletons()
+  {
+    auto &singletons = getSingletons();
+    for (auto singleton : *singletons)
+      delete singleton;
+    delete singletons;
+    singletons = nullptr;
+  }
 
 } // namespace Catch
 // end catch_singletons.cpp
 // start catch_startup_exception_registry.cpp
 
 namespace Catch {
-void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
+  void StartupExceptionRegistry::add(std::exception_ptr const &exception) noexcept
+  {
+    CATCH_TRY { m_exceptions.push_back(exception); }
+    CATCH_CATCH_ALL
+    {
+      // If we run out of memory during start-up there's really not a lot more we can do about it
+      std::terminate();
     }
+  }
 
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
+  std::vector<std::exception_ptr> const &StartupExceptionRegistry::getExceptions() const noexcept
+  {
+    return m_exceptions;
+  }
 
 } // end namespace Catch
 // end catch_startup_exception_registry.cpp
 // start catch_stream.cpp
 
 #include <cstdio>
-#include <iostream>
 #include <fstream>
+#include <iostream>
+#include <memory>
 #include <sstream>
 #include <vector>
-#include <memory>
 
 namespace Catch {
 
-    Catch::IStream::~IStream() = default;
+  Catch::IStream::~IStream() = default;
 
-    namespace Detail { namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
+  namespace Detail {
+    namespace {
+      template <typename WriterF, std::size_t bufferSize = 256>
+      class StreamBufImpl : public std::streambuf
+      {
+        char    data[bufferSize];
+        WriterF m_writer;
 
-            ~StreamBufImpl() noexcept {
-                StreamBufImpl::sync();
-            }
+      public:
+        StreamBufImpl() { setp(data, data + sizeof(data)); }
 
-        private:
-            int overflow( int c ) override {
-                sync();
+        ~StreamBufImpl() noexcept { StreamBufImpl::sync(); }
 
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
+      private:
+        int overflow(int c) override
+        {
+          sync();
 
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
+          if (c != EOF) {
+            if (pbase() == epptr())
+              m_writer(std::string(1, static_cast<char>(c)));
+            else
+              sputc(static_cast<char>(c));
+          }
+          return 0;
+        }
 
-        ///////////////////////////////////////////////////////////////////////////
+        int sync() override
+        {
+          if (pbase() != pptr()) {
+            m_writer(std::string(pbase(), static_cast<std::string::size_type>(pptr() - pbase())));
+            setp(pbase(), epptr());
+          }
+          return 0;
+        }
+      };
 
-        struct OutputDebugWriter {
+      ///////////////////////////////////////////////////////////////////////////
 
-            void operator()( std::string const&str ) {
-                writeToDebugConsole( str );
-            }
-        };
+      struct OutputDebugWriter
+      {
 
-        ///////////////////////////////////////////////////////////////////////////
+        void operator()(std::string const &str) { writeToDebugConsole(str); }
+      };
 
-        class FileStream : public IStream {
-            mutable std::ofstream m_ofs;
-        public:
-            FileStream( StringRef filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-            }
-            ~FileStream() override = default;
-        public: // IStream
-            std::ostream& stream() const override {
-                return m_ofs;
-            }
-        };
+      ///////////////////////////////////////////////////////////////////////////
 
-        ///////////////////////////////////////////////////////////////////////////
+      class FileStream : public IStream
+      {
+        mutable std::ofstream m_ofs;
 
-        class CoutStream : public IStream {
-            mutable std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-            ~CoutStream() override = default;
+      public:
+        FileStream(StringRef filename)
+        {
+          m_ofs.open(filename.c_str());
+          CATCH_ENFORCE(!m_ofs.fail(), "Unable to open file: '" << filename << "'");
+        }
+        ~FileStream() override = default;
 
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
+      public: // IStream
+        std::ostream &stream() const override { return m_ofs; }
+      };
 
-        ///////////////////////////////////////////////////////////////////////////
+      ///////////////////////////////////////////////////////////////////////////
 
-        class DebugOutStream : public IStream {
-            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            mutable std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-                m_os( m_streamBuf.get() )
-            {}
+      class CoutStream : public IStream
+      {
+        mutable std::ostream m_os;
 
-            ~DebugOutStream() override = default;
+      public:
+        // Store the streambuf from cout up-front because
+        // cout may get redirected when running tests
+        CoutStream() : m_os(Catch::cout().rdbuf()) {}
+        ~CoutStream() override = default;
 
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
+      public: // IStream
+        std::ostream &stream() const override { return m_os; }
+      };
 
-    }} // namespace anon::detail
+      ///////////////////////////////////////////////////////////////////////////
 
-    ///////////////////////////////////////////////////////////////////////////
+      class DebugOutStream : public IStream
+      {
+        std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+        mutable std::ostream                              m_os;
 
-    auto makeStream( StringRef const &filename ) -> IStream const* {
-        if( filename.empty() )
-            return new Detail::CoutStream();
-        else if( filename[0] == '%' ) {
-            if( filename == "%debug" )
-                return new Detail::DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+      public:
+        DebugOutStream()
+            : m_streamBuf(new StreamBufImpl<OutputDebugWriter>()), m_os(m_streamBuf.get())
+        {
         }
-        else
-            return new Detail::FileStream( filename );
-    }
 
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+        ~DebugOutStream() override = default;
 
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
+      public: // IStream
+        std::ostream &stream() const override { return m_os; }
+      };
 
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
+    } // namespace
+  }   // namespace Detail
 
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
+  ///////////////////////////////////////////////////////////////////////////
 
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
+  auto makeStream(StringRef const &filename) -> IStream const *
+  {
+    if (filename.empty())
+      return new Detail::CoutStream();
+    else if (filename[0] == '%') {
+      if (filename == "%debug")
+        return new Detail::DebugOutStream();
+      else
+        CATCH_ERROR("Unrecognised stream: '" << filename << "'");
     }
+    else
+      return new Detail::FileStream(filename);
+  }
+
+  // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+  struct StringStreams
+  {
+    std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+    std::vector<std::size_t>                         m_unused;
+    std::ostringstream m_referenceStream; // Used for copy state/ flags from
 
-    auto ReusableStringStream::str() const -> std::string {
-        return static_cast<std::ostringstream*>( m_oss )->str();
+    auto add() -> std::size_t
+    {
+      if (m_unused.empty()) {
+        m_streams.push_back(std::unique_ptr<std::ostringstream>(new std::ostringstream));
+        return m_streams.size() - 1;
+      }
+      else {
+        auto index = m_unused.back();
+        m_unused.pop_back();
+        return index;
+      }
+    }
+
+    void release(std::size_t index)
+    {
+      m_streams[index]->copyfmt(m_referenceStream); // Restore initial flags and other state
+      m_unused.push_back(index);
     }
+  };
+
+  ReusableStringStream::ReusableStringStream()
+      : m_index(Singleton<StringStreams>::getMutable().add()),
+        m_oss(Singleton<StringStreams>::getMutable().m_streams[m_index].get())
+  {
+  }
+
+  ReusableStringStream::~ReusableStringStream()
+  {
+    static_cast<std::ostringstream *>(m_oss)->str("");
+    m_oss->clear();
+    Singleton<StringStreams>::getMutable().release(m_index);
+  }
+
+  auto ReusableStringStream::str() const -> std::string
+  {
+    return static_cast<std::ostringstream *>(m_oss)->str();
+  }
 
-    ///////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////
 
 #ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
+  std::ostream &cout() { return std::cout; }
+  std::ostream &cerr() { return std::cerr; }
+  std::ostream &clog() { return std::clog; }
 #endif
-}
+} // namespace Catch
 // end catch_stream.cpp
 // start catch_string_manip.cpp
 
 #include <algorithm>
-#include <ostream>
-#include <cstring>
 #include <cctype>
+#include <cstring>
+#include <ostream>
 #include <vector>
 
 namespace Catch {
 
-    namespace {
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-    }
+  namespace {
+    char toLowerCh(char c) { return static_cast<char>(std::tolower(c)); }
+  } // namespace
 
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+  bool startsWith(std::string const &s, std::string const &prefix)
+  {
+    return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+  }
+  bool startsWith(std::string const &s, char prefix) { return !s.empty() && s[0] == prefix; }
+  bool endsWith(std::string const &s, std::string const &suffix)
+  {
+    return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+  }
+  bool endsWith(std::string const &s, char suffix)
+  {
+    return !s.empty() && s[s.size() - 1] == suffix;
+  }
+  bool contains(std::string const &s, std::string const &infix)
+  {
+    return s.find(infix) != std::string::npos;
+  }
+  void toLowerInPlace(std::string &s) { std::transform(s.begin(), s.end(), s.begin(), toLowerCh); }
+  std::string toLower(std::string const &s)
+  {
+    std::string lc = s;
+    toLowerInPlace(lc);
+    return lc;
+  }
+  std::string trim(std::string const &str)
+  {
+    static char const *    whitespaceChars = "\n\r\t ";
+    std::string::size_type start           = str.find_first_not_of(whitespaceChars);
+    std::string::size_type end             = str.find_last_not_of(whitespaceChars);
+
+    return start != std::string::npos ? str.substr(start, 1 + end - start) : std::string();
+  }
+
+  StringRef trim(StringRef ref)
+  {
+    const auto is_ws      = [](char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; };
+    size_t     real_begin = 0;
+    while (real_begin < ref.size() && is_ws(ref[real_begin])) {
+      ++real_begin;
     }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
+    size_t real_end = ref.size();
+    while (real_end > real_begin && is_ws(ref[real_end - 1])) {
+      --real_end;
     }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
 
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
+    return ref.substr(real_begin, real_end - real_begin);
+  }
 
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
+  bool replaceInPlace(std::string &str, std::string const &replaceThis, std::string const &withThis)
+  {
+    bool        replaced = false;
+    std::size_t i        = str.find(replaceThis);
+    while (i != std::string::npos) {
+      replaced = true;
+      str      = str.substr(0, i) + withThis + str.substr(i + replaceThis.size());
+      if (i < str.size() - withThis.size())
+        i = str.find(replaceThis, i + withThis.size());
+      else
+        i = std::string::npos;
+    }
+    return replaced;
+  }
 
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
+  std::vector<StringRef> splitStringRef(StringRef str, char delimiter)
+  {
+    std::vector<StringRef> subStrings;
+    std::size_t            start = 0;
+    for (std::size_t pos = 0; pos < str.size(); ++pos) {
+      if (str[pos] == delimiter) {
+        if (pos - start > 1)
+          subStrings.push_back(str.substr(start, pos - start));
+        start = pos + 1;
+      }
+    }
+    if (start < str.size())
+      subStrings.push_back(str.substr(start, str.size() - start));
+    return subStrings;
+  }
 
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
+  pluralise::pluralise(std::size_t count, std::string const &label) : m_count(count), m_label(label)
+  {
+  }
 
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
+  std::ostream &operator<<(std::ostream &os, pluralise const &pluraliser)
+  {
+    os << pluraliser.m_count << ' ' << pluraliser.m_label;
+    if (pluraliser.m_count != 1)
+      os << 's';
+    return os;
+  }
 
-}
+} // namespace Catch
 // end catch_string_manip.cpp
 // start catch_stringref.cpp
 
 #if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
 #endif
 
-#include <ostream>
-#include <cstring>
 #include <cstdint>
-
-namespace {
-    const uint32_t byte_2_lead = 0xC0;
-    const uint32_t byte_3_lead = 0xE0;
-    const uint32_t byte_4_lead = 0xF0;
-}
+#include <cstring>
+#include <ostream>
 
 namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
-    {}
-
-    StringRef::operator std::string() const {
-        return std::string( m_start, m_size );
-    }
-
-    void StringRef::swap( StringRef& other ) noexcept {
-        std::swap( m_start, other.m_start );
-        std::swap( m_size, other.m_size );
-        std::swap( m_data, other.m_data );
-    }
-
-    auto StringRef::c_str() const -> char const* {
-        if( !isSubstring() )
-            return m_start;
-
-        const_cast<StringRef *>( this )->takeOwnership();
-        return m_data;
-    }
-    auto StringRef::currentData() const noexcept -> char const* {
-        return m_start;
-    }
+  StringRef::StringRef(char const *rawChars) noexcept
+      : StringRef(rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars)))
+  {
+  }
 
-    auto StringRef::isOwned() const noexcept -> bool {
-        return m_data != nullptr;
-    }
-    auto StringRef::isSubstring() const noexcept -> bool {
-        return m_start[m_size] != '\0';
-    }
+  void StringRef::swap(StringRef &other) noexcept
+  {
+    std::swap(m_start, other.m_start);
+    std::swap(m_size, other.m_size);
+    std::swap(m_data, other.m_data);
+  }
 
-    void StringRef::takeOwnership() {
-        if( !isOwned() ) {
-            m_data = new char[m_size+1];
-            memcpy( m_data, m_start, m_size );
-            m_data[m_size] = '\0';
-        }
-    }
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if( start < m_size )
-            return StringRef( m_start+start, size );
-        else
-            return StringRef();
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return
-            size() == other.size() &&
-            (std::strncmp( m_start, other.m_start, size() ) == 0);
-    }
-    auto StringRef::operator != ( StringRef const& other ) const noexcept -> bool {
-        return !operator==( other );
-    }
+  auto StringRef::c_str() const -> char const *
+  {
+    if (!isSubstring())
+      return m_start;
 
-    auto StringRef::operator[](size_type index) const noexcept -> char {
-        return m_start[index];
-    }
+    const_cast<StringRef *>(this)->takeOwnership();
+    return m_data;
+  }
+  auto StringRef::currentData() const noexcept -> char const * { return m_start; }
 
-    auto StringRef::numberOfCharacters() const noexcept -> size_type {
-        size_type noChars = m_size;
-        // Make adjustments for uft encodings
-        for( size_type i=0; i < m_size; ++i ) {
-            char c = m_start[i];
-            if( ( c & byte_2_lead ) == byte_2_lead ) {
-                noChars--;
-                if (( c & byte_3_lead ) == byte_3_lead )
-                    noChars--;
-                if( ( c & byte_4_lead ) == byte_4_lead )
-                    noChars--;
-            }
-        }
-        return noChars;
-    }
+  auto StringRef::isOwned() const noexcept -> bool { return m_data != nullptr; }
+  auto StringRef::isSubstring() const noexcept -> bool { return m_start[m_size] != '\0'; }
 
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string {
-        std::string str;
-        str.reserve( lhs.size() + rhs.size() );
-        str += lhs;
-        str += rhs;
-        return str;
-    }
-    auto operator + ( StringRef const& lhs, const char* rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
-    }
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
+  void StringRef::takeOwnership()
+  {
+    if (!isOwned()) {
+      m_data = new char[m_size + 1];
+      memcpy(m_data, m_start, m_size);
+      m_data[m_size] = '\0';
     }
+  }
+  auto StringRef::substr(size_type start, size_type size) const noexcept -> StringRef
+  {
+    if (start < m_size)
+      return StringRef(m_start + start, size);
+    else
+      return StringRef();
+  }
+  auto StringRef::operator==(StringRef const &other) const noexcept -> bool
+  {
+    return size() == other.size() && (std::strncmp(m_start, other.m_start, size()) == 0);
+  }
+  auto StringRef::operator!=(StringRef const &other) const noexcept -> bool
+  {
+    return !operator==(other);
+  }
 
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.currentData(), str.size());
-    }
+  auto operator<<(std::ostream &os, StringRef const &str) -> std::ostream &
+  {
+    return os.write(str.currentData(), str.size());
+  }
 
-    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.currentData(), rhs.size());
-        return lhs;
-    }
+  auto operator+=(std::string &lhs, StringRef const &rhs) -> std::string &
+  {
+    lhs.append(rhs.currentData(), rhs.size());
+    return lhs;
+  }
 
 } // namespace Catch
 
 #if defined(__clang__)
-#    pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #endif
 // end catch_stringref.cpp
 // start catch_tag_alias.cpp
 
 namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
-}
+  TagAlias::TagAlias(std::string const &_tag, SourceLineInfo _lineInfo)
+      : tag(_tag), lineInfo(_lineInfo)
+  {
+  }
+} // namespace Catch
 // end catch_tag_alias.cpp
 // start catch_tag_alias_autoregistrar.cpp
 
 namespace Catch {
 
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
+  RegistrarForTagAliases::RegistrarForTagAliases(char const *alias, char const *tag,
+                                                 SourceLineInfo const &lineInfo)
+  {
+    CATCH_TRY { getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo); }
+    CATCH_CATCH_ALL
+    {
+      // Do not throw when constructing global objects, instead register the exception to be
+      // processed later
+      getMutableRegistryHub().registerStartupException();
     }
+  }
 
-}
+} // namespace Catch
 // end catch_tag_alias_autoregistrar.cpp
 // start catch_tag_alias_registry.cpp
 
@@ -13394,217 +14607,211 @@ namespace Catch {
 
 namespace Catch {
 
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
+  TagAliasRegistry::~TagAliasRegistry() {}
 
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
+  TagAlias const *TagAliasRegistry::find(std::string const &alias) const
+  {
+    auto it = m_registry.find(alias);
+    if (it != m_registry.end())
+      return &(it->second);
+    else
+      return nullptr;
+  }
 
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+  std::string TagAliasRegistry::expandAliases(std::string const &unexpandedTestSpec) const
+  {
+    std::string expandedTestSpec = unexpandedTestSpec;
+    for (auto const &registryKvp : m_registry) {
+      std::size_t pos = expandedTestSpec.find(registryKvp.first);
+      if (pos != std::string::npos) {
+        expandedTestSpec = expandedTestSpec.substr(0, pos) + registryKvp.second.tag +
+                           expandedTestSpec.substr(pos + registryKvp.first.size());
+      }
+    }
+    return expandedTestSpec;
+  }
 
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
+  void TagAliasRegistry::add(std::string const &alias, std::string const &tag,
+                             SourceLineInfo const &lineInfo)
+  {
+    CATCH_ENFORCE(startsWith(alias, "[@") && endsWith(alias, ']'),
+                  "error: tag alias, '" << alias << "' is not of the form [@alias name].\n"
+                                        << lineInfo);
+
+    CATCH_ENFORCE(m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                  "error: tag alias, '" << alias << "' already registered.\n"
+                                        << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                                        << "\tRedefined at: " << lineInfo);
+  }
 
-    ITagAliasRegistry::~ITagAliasRegistry() {}
+  ITagAliasRegistry::~ITagAliasRegistry() {}
 
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
+  ITagAliasRegistry const &ITagAliasRegistry::get()
+  {
+    return getRegistryHub().getTagAliasRegistry();
+  }
 
 } // end namespace Catch
 // end catch_tag_alias_registry.cpp
 // start catch_test_case_info.cpp
 
+#include <algorithm>
 #include <cctype>
 #include <exception>
-#include <algorithm>
 #include <sstream>
 
 namespace Catch {
 
-    namespace {
-        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-            if( startsWith( tag, '.' ) ||
-                tag == "!hide" )
-                return TestCaseInfo::IsHidden;
-            else if( tag == "!throws" )
-                return TestCaseInfo::Throws;
-            else if( tag == "!shouldfail" )
-                return TestCaseInfo::ShouldFail;
-            else if( tag == "!mayfail" )
-                return TestCaseInfo::MayFail;
-            else if( tag == "!nonportable" )
-                return TestCaseInfo::NonPortable;
-            else if( tag == "!benchmark" )
-                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-            else
-                return TestCaseInfo::None;
-        }
-        bool isReservedTag( std::string const& tag ) {
-            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
+  namespace {
+    TestCaseInfo::SpecialProperties parseSpecialTag(std::string const &tag)
+    {
+      if (startsWith(tag, '.') || tag == "!hide")
+        return TestCaseInfo::IsHidden;
+      else if (tag == "!throws")
+        return TestCaseInfo::Throws;
+      else if (tag == "!shouldfail")
+        return TestCaseInfo::ShouldFail;
+      else if (tag == "!mayfail")
+        return TestCaseInfo::MayFail;
+      else if (tag == "!nonportable")
+        return TestCaseInfo::NonPortable;
+      else if (tag == "!benchmark")
+        return static_cast<TestCaseInfo::SpecialProperties>(TestCaseInfo::Benchmark |
+                                                            TestCaseInfo::IsHidden);
+      else
+        return TestCaseInfo::None;
+    }
+    bool isReservedTag(std::string const &tag)
+    {
+      return parseSpecialTag(tag) == TestCaseInfo::None && tag.size() > 0 &&
+             !std::isalnum(static_cast<unsigned char>(tag[0]));
     }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& _lineInfo )
+    void enforceNotReservedTag(std::string const &tag, SourceLineInfo const &_lineInfo)
     {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        std::string _descOrTags = nameAndTags.tags;
-        for (char c : _descOrTags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    // Merged hide tags like `[.approvals]` should be added as
-                    // `[.][approvals]`. The `[.]` is added at later point, so
-                    // we only strip the prefix
-                    if (startsWith(tag, '.') && tag.size() > 1) {
-                        tag.erase(0, 1);
-                    }
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            tags.push_back( "." );
+      CATCH_ENFORCE(
+          !isReservedTag(tag),
+          "Tag name: [" << tag << "] is not allowed.\n"
+                        << "Tag names starting with non alphanumeric characters are reserved\n"
+                        << _lineInfo);
+    }
+  } // namespace
+
+  TestCase makeTestCase(ITestInvoker *_testCase, std::string const &_className,
+                        NameAndTags const &nameAndTags, SourceLineInfo const &_lineInfo)
+  {
+    bool isHidden = false;
+
+    // Parse out tags
+    std::vector<std::string> tags;
+    std::string              desc, tag;
+    bool                     inTag = false;
+    for (char c : nameAndTags.tags) {
+      if (!inTag) {
+        if (c == '[')
+          inTag = true;
+        else
+          desc += c;
+      }
+      else {
+        if (c == ']') {
+          TestCaseInfo::SpecialProperties prop = parseSpecialTag(tag);
+          if ((prop & TestCaseInfo::IsHidden) != 0)
+            isHidden = true;
+          else if (prop == TestCaseInfo::None)
+            enforceNotReservedTag(tag, _lineInfo);
+
+          // Merged hide tags like `[.approvals]` should be added as
+          // `[.][approvals]`. The `[.]` is added at later point, so
+          // we only strip the prefix
+          if (startsWith(tag, '.') && tag.size() > 1) {
+            tag.erase(0, 1);
+          }
+          tags.push_back(tag);
+          tag.clear();
+          inTag = false;
         }
-
-        TestCaseInfo info( nameAndTags.name, _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, std::move(info) );
+        else
+          tag += c;
+      }
+    }
+    if (isHidden) {
+      tags.push_back(".");
     }
 
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
+    TestCaseInfo info(static_cast<std::string>(nameAndTags.name), _className, desc, tags,
+                      _lineInfo);
+    return TestCase(_testCase, std::move(info));
+  }
 
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
+  void setTags(TestCaseInfo &testCaseInfo, std::vector<std::string> tags)
+  {
+    std::sort(begin(tags), end(tags));
+    tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+    testCaseInfo.lcaseTags.clear();
 
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
+    for (auto const &tag : tags) {
+      std::string lcaseTag    = toLower(tag);
+      testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>(
+          testCaseInfo.properties | parseSpecialTag(lcaseTag));
+      testCaseInfo.lcaseTags.push_back(lcaseTag);
     }
+    testCaseInfo.tags = std::move(tags);
+  }
 
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
+  TestCaseInfo::TestCaseInfo(std::string const &_name, std::string const &_className,
+                             std::string const &_description, std::vector<std::string> const &_tags,
+                             SourceLineInfo const &_lineInfo)
+      : name(_name), className(_className), description(_description), lineInfo(_lineInfo),
+        properties(None)
+  {
+    setTags(*this, _tags);
+  }
 
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
+  bool TestCaseInfo::isHidden() const { return (properties & IsHidden) != 0; }
+  bool TestCaseInfo::throws() const { return (properties & Throws) != 0; }
+  bool TestCaseInfo::okToFail() const { return (properties & (ShouldFail | MayFail)) != 0; }
+  bool TestCaseInfo::expectedToFail() const { return (properties & (ShouldFail)) != 0; }
 
-        return ret;
+  std::string TestCaseInfo::tagsAsString() const
+  {
+    std::string ret;
+    // '[' and ']' per tag
+    std::size_t full_size = 2 * tags.size();
+    for (const auto &tag : tags) {
+      full_size += tag.size();
+    }
+    ret.reserve(full_size);
+    for (const auto &tag : tags) {
+      ret.push_back('[');
+      ret.append(tag);
+      ret.push_back(']');
     }
 
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+    return ret;
+  }
 
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
+  TestCase::TestCase(ITestInvoker *testCase, TestCaseInfo &&info)
+      : TestCaseInfo(std::move(info)), test(testCase)
+  {
+  }
 
-    void TestCase::invoke() const {
-        test->invoke();
-    }
+  TestCase TestCase::withName(std::string const &_newName) const
+  {
+    TestCase other(*this);
+    other.name = _newName;
+    return other;
+  }
 
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
+  void TestCase::invoke() const { test->invoke(); }
 
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
+  bool TestCase::operator==(TestCase const &other) const
+  {
+    return test.get() == other.test.get() && name == other.name && className == other.className;
+  }
 
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
+  bool TestCase::operator<(TestCase const &other) const { return name < other.name; }
+
+  TestCaseInfo const &TestCase::getTestCaseInfo() const { return *this; }
 
 } // end namespace Catch
 // end catch_test_case_info.cpp
@@ -13614,102 +14821,110 @@ namespace Catch {
 
 namespace Catch {
 
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+  std::vector<TestCase> sortTests(IConfig const &              config,
+                                  std::vector<TestCase> const &unsortedTestCases)
+  {
 
-        std::vector<TestCase> sorted = unsortedTestCases;
+    std::vector<TestCase> sorted = unsortedTestCases;
 
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                std::shuffle( sorted.begin(), sorted.end(), rng() );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
+    switch (config.runOrder()) {
+    case RunTests::InLexicographicalOrder: std::sort(sorted.begin(), sorted.end()); break;
+    case RunTests::InRandomOrder:
+      seedRng(config);
+      std::shuffle(sorted.begin(), sorted.end(), rng());
+      break;
+    case RunTests::InDeclarationOrder:
+      // already in declaration order
+      break;
     }
+    return sorted;
+  }
 
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
-        return !testCase.throws() || config.allowThrows();
-    }
+  bool isThrowSafe(TestCase const &testCase, IConfig const &config)
+  {
+    return !testCase.throws() || config.allowThrows();
+  }
 
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
-    }
+  bool matchTest(TestCase const &testCase, TestSpec const &testSpec, IConfig const &config)
+  {
+    return testSpec.matches(testCase) && isThrowSafe(testCase, config);
+  }
 
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
+  void enforceNoDuplicateTestCases(std::vector<TestCase> const &functions)
+  {
+    std::set<TestCase> seenFunctions;
+    for (auto const &function : functions) {
+      auto prev = seenFunctions.insert(function);
+      CATCH_ENFORCE(prev.second, "error: TEST_CASE( \""
+                                     << function.name << "\" ) already defined.\n"
+                                     << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo
+                                     << "\n"
+                                     << "\tRedefined at " << function.getTestCaseInfo().lineInfo);
     }
+  }
 
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
+  std::vector<TestCase> filterTests(std::vector<TestCase> const &testCases,
+                                    TestSpec const &testSpec, IConfig const &config)
+  {
+    std::vector<TestCase> filtered;
+    filtered.reserve(testCases.size());
+    for (auto const &testCase : testCases) {
+      if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+          (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+        filtered.push_back(testCase);
+      }
+    }
+    return filtered;
+  }
+  std::vector<TestCase> const &getAllTestCasesSorted(IConfig const &config)
+  {
+    return getRegistryHub().getTestCaseRegistry().getAllTestsSorted(config);
+  }
 
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            ReusableStringStream rss;
-            rss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( rss.str() ) );
-        }
-        m_functions.push_back( testCase );
+  void TestRegistry::registerTest(TestCase const &testCase)
+  {
+    std::string name = testCase.getTestCaseInfo().name;
+    if (name.empty()) {
+      ReusableStringStream rss;
+      rss << "Anonymous test case " << ++m_unnamedCount;
+      return registerTest(testCase.withName(rss.str()));
     }
+    m_functions.push_back(testCase);
+  }
 
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
+  std::vector<TestCase> const &TestRegistry::getAllTests() const { return m_functions; }
+  std::vector<TestCase> const &TestRegistry::getAllTestsSorted(IConfig const &config) const
+  {
+    if (m_sortedFunctions.empty())
+      enforceNoDuplicateTestCases(m_functions);
 
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
+    if (m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty()) {
+      m_sortedFunctions  = sortTests(config, m_functions);
+      m_currentSortOrder = config.runOrder();
     }
+    return m_sortedFunctions;
+  }
 
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+  ///////////////////////////////////////////////////////////////////////////
+  TestInvokerAsFunction::TestInvokerAsFunction(void (*testAsFunction)()) noexcept
+      : m_testAsFunction(testAsFunction)
+  {
+  }
 
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
+  void TestInvokerAsFunction::invoke() const { m_testAsFunction(); }
 
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className = classOrQualifiedMethodName;
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
+  std::string extractClassName(StringRef const &classOrQualifiedMethodName)
+  {
+    std::string className(classOrQualifiedMethodName);
+    if (startsWith(className, '&')) {
+      std::size_t lastColons        = className.rfind("::");
+      std::size_t penultimateColons = className.rfind("::", lastColons - 1);
+      if (penultimateColons == std::string::npos)
+        penultimateColons = 1;
+      className = className.substr(penultimateColons, lastColons - penultimateColons);
     }
+    return className;
+  }
 
 } // end namespace Catch
 // end catch_test_case_registry_impl.cpp
@@ -13717,485 +14932,505 @@ namespace Catch {
 
 #include <algorithm>
 #include <cassert>
-#include <stdexcept>
 #include <memory>
 #include <sstream>
+#include <stdexcept>
 
 #if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
 #endif
 
 namespace Catch {
-namespace TestCaseTracking {
+  namespace TestCaseTracking {
 
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
+    NameAndLocation::NameAndLocation(std::string const &_name, SourceLineInfo const &_location)
+        : name(_name), location(_location)
+    {
+    }
 
     ITracker::~ITracker() = default;
 
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
+    ITracker &TrackerContext::startRun()
+    {
+      m_rootTracker = std::make_shared<SectionTracker>(
+          NameAndLocation("{root}", CATCH_INTERNAL_LINEINFO), *this, nullptr);
+      m_currentTracker = nullptr;
+      m_runState       = Executing;
+      return *m_rootTracker;
     }
 
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
+    void TrackerContext::endRun()
+    {
+      m_rootTracker.reset();
+      m_currentTracker = nullptr;
+      m_runState       = NotStarted;
     }
 
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
+    void TrackerContext::startCycle()
+    {
+      m_currentTracker = m_rootTracker.get();
+      m_runState       = Executing;
     }
+    void TrackerContext::completeCycle() { m_runState = CompletedCycle; }
 
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
+    bool      TrackerContext::completedCycle() const { return m_runState == CompletedCycle; }
+    ITracker &TrackerContext::currentTracker() { return *m_currentTracker; }
+    void      TrackerContext::setCurrentTracker(ITracker *tracker) { m_currentTracker = tracker; }
 
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
+    TrackerBase::TrackerBase(NameAndLocation const &nameAndLocation, TrackerContext &ctx,
+                             ITracker *parent)
+        : m_nameAndLocation(nameAndLocation), m_ctx(ctx), m_parent(parent)
+    {
     }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
+
+    NameAndLocation const &TrackerBase::nameAndLocation() const { return m_nameAndLocation; }
+    bool                   TrackerBase::isComplete() const
+    {
+      return m_runState == CompletedSuccessfully || m_runState == Failed;
     }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
+    bool TrackerBase::isSuccessfullyCompleted() const
+    {
+      return m_runState == CompletedSuccessfully;
     }
+    bool TrackerBase::isOpen() const { return m_runState != NotStarted && !isComplete(); }
+    bool TrackerBase::hasChildren() const { return !m_children.empty(); }
 
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
+    void TrackerBase::addChild(ITrackerPtr const &child) { m_children.push_back(child); }
 
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ){
-                return
-                    tracker->nameAndLocation().location == nameAndLocation.location &&
-                    tracker->nameAndLocation().name == nameAndLocation.name;
-            } );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
+    ITrackerPtr TrackerBase::findChild(NameAndLocation const &nameAndLocation)
+    {
+      auto it = std::find_if(
+          m_children.begin(), m_children.end(), [&nameAndLocation](ITrackerPtr const &tracker) {
+            return tracker->nameAndLocation().location == nameAndLocation.location &&
+                   tracker->nameAndLocation().name == nameAndLocation.name;
+          });
+      return (it != m_children.end()) ? *it : nullptr;
+    }
+    ITracker &TrackerBase::parent()
+    {
+      assert(m_parent); // Should always be non-null except for root
+      return *m_parent;
     }
 
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
+    void TrackerBase::openChild()
+    {
+      if (m_runState != ExecutingChildren) {
+        m_runState = ExecutingChildren;
+        if (m_parent)
+          m_parent->openChild();
+      }
     }
 
     bool TrackerBase::isSectionTracker() const { return false; }
     bool TrackerBase::isGeneratorTracker() const { return false; }
 
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
+    void TrackerBase::open()
+    {
+      m_runState = Executing;
+      moveToThis();
+      if (m_parent)
+        m_parent->openChild();
     }
 
-    void TrackerBase::close() {
+    void TrackerBase::close()
+    {
 
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
+      // Close any still open children (e.g. generators)
+      while (&m_ctx.currentTracker() != this)
+        m_ctx.currentTracker().close();
 
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
+      switch (m_runState) {
+      case NeedsAnotherRun: break;
 
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
-                    m_runState = CompletedSuccessfully;
-                break;
+      case Executing: m_runState = CompletedSuccessfully; break;
+      case ExecutingChildren:
+        if (std::all_of(m_children.begin(), m_children.end(),
+                        [](ITrackerPtr const &t) { return t->isComplete(); }))
+          m_runState = CompletedSuccessfully;
+        break;
 
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+      case NotStarted:
+      case CompletedSuccessfully:
+      case Failed: CATCH_INTERNAL_ERROR("Illogical state: " << m_runState);
 
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
+      default: CATCH_INTERNAL_ERROR("Unknown state: " << m_runState);
+      }
+      moveToParent();
+      m_ctx.completeCycle();
     }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
+    void TrackerBase::fail()
+    {
+      m_runState = Failed;
+      if (m_parent)
+        m_parent->markAsNeedingAnotherRun();
+      moveToParent();
+      m_ctx.completeCycle();
     }
+    void TrackerBase::markAsNeedingAnotherRun() { m_runState = NeedsAnotherRun; }
 
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
+    void TrackerBase::moveToParent()
+    {
+      assert(m_parent);
+      m_ctx.setCurrentTracker(m_parent);
     }
+    void TrackerBase::moveToThis() { m_ctx.setCurrentTracker(this); }
 
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent )
+    SectionTracker::SectionTracker(NameAndLocation const &nameAndLocation, TrackerContext &ctx,
+                                   ITracker *parent)
+        : TrackerBase(nameAndLocation, ctx, parent), m_trimmed_name(trim(nameAndLocation.name))
     {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
+      if (parent) {
+        while (!parent->isSectionTracker())
+          parent = &parent->parent();
 
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
+        SectionTracker &parentSection = static_cast<SectionTracker &>(*parent);
+        addNextFilters(parentSection.m_filters);
+      }
     }
 
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if ((m_filters.empty() || m_filters[0] == "") ||
-             std::find(m_filters.begin(), m_filters.end(),
-                       m_nameAndLocation.name) != m_filters.end())
-            complete = TrackerBase::isComplete();
-        return complete;
+    bool SectionTracker::isComplete() const
+    {
+      bool complete = true;
 
+      if ((m_filters.empty() || m_filters[0] == "") ||
+          std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+        complete = TrackerBase::isComplete();
+      }
+      return complete;
     }
 
     bool SectionTracker::isSectionTracker() const { return true; }
 
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
-            open();
+    SectionTracker &SectionTracker::acquire(TrackerContext &       ctx,
+                                            NameAndLocation const &nameAndLocation)
+    {
+      std::shared_ptr<SectionTracker> section;
+
+      ITracker &currentTracker = ctx.currentTracker();
+      if (ITrackerPtr childTracker = currentTracker.findChild(nameAndLocation)) {
+        assert(childTracker);
+        assert(childTracker->isSectionTracker());
+        section = std::static_pointer_cast<SectionTracker>(childTracker);
+      }
+      else {
+        section = std::make_shared<SectionTracker>(nameAndLocation, ctx, &currentTracker);
+        currentTracker.addChild(section);
+      }
+      if (!ctx.completedCycle())
+        section->tryOpen();
+      return *section;
+    }
+
+    void SectionTracker::tryOpen()
+    {
+      if (!isComplete())
+        open();
     }
 
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.push_back(""); // Root - should never be consulted
-            m_filters.push_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
+    void SectionTracker::addInitialFilters(std::vector<std::string> const &filters)
+    {
+      if (!filters.empty()) {
+        m_filters.reserve(m_filters.size() + filters.size() + 2);
+        m_filters.push_back(""); // Root - should never be consulted
+        m_filters.push_back(""); // Test Case - not a section filter
+        m_filters.insert(m_filters.end(), filters.begin(), filters.end());
+      }
+    }
+    void SectionTracker::addNextFilters(std::vector<std::string> const &filters)
+    {
+      if (filters.size() > 1)
+        m_filters.insert(m_filters.end(), filters.begin() + 1, filters.end());
     }
 
-} // namespace TestCaseTracking
+  } // namespace TestCaseTracking
 
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
+  using TestCaseTracking::ITracker;
+  using TestCaseTracking::SectionTracker;
+  using TestCaseTracking::TrackerContext;
 
 } // namespace Catch
 
 #if defined(__clang__)
-#    pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #endif
 // end catch_test_case_tracker.cpp
 // start catch_test_registry.cpp
 
 namespace Catch {
 
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
+  auto makeTestInvoker(void (*testAsFunction)()) noexcept -> ITestInvoker *
+  {
+    return new (std::nothrow) TestInvokerAsFunction(testAsFunction);
+  }
 
-    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+  NameAndTags::NameAndTags(StringRef const &name_, StringRef const &tags_) noexcept
+      : name(name_), tags(tags_)
+  {
+  }
 
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo));
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
+  AutoReg::AutoReg(ITestInvoker *invoker, SourceLineInfo const &lineInfo,
+                   StringRef const &classOrMethod, NameAndTags const &nameAndTags) noexcept
+  {
+    CATCH_TRY
+    {
+      getMutableRegistryHub().registerTest(
+          makeTestCase(invoker, extractClassName(classOrMethod), nameAndTags, lineInfo));
+    }
+    CATCH_CATCH_ALL
+    {
+      // Do not throw when constructing global objects, instead register the exception to be
+      // processed later
+      getMutableRegistryHub().registerStartupException();
     }
+  }
 
-    AutoReg::~AutoReg() = default;
-}
+  AutoReg::~AutoReg() = default;
+} // namespace Catch
 // end catch_test_registry.cpp
 // start catch_test_spec.cpp
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
 
 namespace Catch {
 
-    TestSpec::Pattern::Pattern( std::string const& name )
-    : m_name( name )
-    {}
+  TestSpec::Pattern::Pattern(std::string const &name) : m_name(name) {}
 
-    TestSpec::Pattern::~Pattern() = default;
+  TestSpec::Pattern::~Pattern() = default;
 
-    std::string const& TestSpec::Pattern::name() const {
-        return m_name;
-    }
+  std::string const &TestSpec::Pattern::name() const { return m_name; }
 
-    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
-    : Pattern( filterString )
-    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
+  TestSpec::NamePattern::NamePattern(std::string const &name, std::string const &filterString)
+      : Pattern(filterString), m_wildcardPattern(toLower(name), CaseSensitive::No)
+  {
+  }
 
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( toLower( testCase.name ) );
-    }
+  bool TestSpec::NamePattern::matches(TestCaseInfo const &testCase) const
+  {
+    return m_wildcardPattern.matches(testCase.name);
+  }
 
-    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
-    : Pattern( filterString )
-    , m_tag( toLower( tag ) )
-    {}
+  TestSpec::TagPattern::TagPattern(std::string const &tag, std::string const &filterString)
+      : Pattern(filterString), m_tag(toLower(tag))
+  {
+  }
 
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
+  bool TestSpec::TagPattern::matches(TestCaseInfo const &testCase) const
+  {
+    return std::find(begin(testCase.lcaseTags), end(testCase.lcaseTags), m_tag) !=
+           end(testCase.lcaseTags);
+  }
+
+  TestSpec::ExcludedPattern::ExcludedPattern(PatternPtr const &underlyingPattern)
+      : Pattern(underlyingPattern->name()), m_underlyingPattern(underlyingPattern)
+  {
+  }
 
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
-    : Pattern( underlyingPattern->name() )
-    , m_underlyingPattern( underlyingPattern )
-    {}
+  bool TestSpec::ExcludedPattern::matches(TestCaseInfo const &testCase) const
+  {
+    return !m_underlyingPattern->matches(testCase);
+  }
 
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
-        return !m_underlyingPattern->matches( testCase );
-    }
+  bool TestSpec::Filter::matches(TestCaseInfo const &testCase) const
+  {
+    return std::all_of(m_patterns.begin(), m_patterns.end(),
+                       [&](PatternPtr const &p) { return p->matches(testCase); });
+  }
 
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
-    }
+  std::string TestSpec::Filter::name() const
+  {
+    std::string name;
+    for (auto const &p : m_patterns)
+      name += p->name();
+    return name;
+  }
 
-    std::string TestSpec::Filter::name() const {
-        std::string name;
-        for( auto const& p : m_patterns )
-            name += p->name();
-        return name;
-    }
+  bool TestSpec::hasFilters() const { return !m_filters.empty(); }
 
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
+  bool TestSpec::matches(TestCaseInfo const &testCase) const
+  {
+    return std::any_of(m_filters.begin(), m_filters.end(),
+                       [&](Filter const &f) { return f.matches(testCase); });
+  }
 
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
-    }
+  TestSpec::Matches TestSpec::matchesByFilter(std::vector<TestCase> const &testCases,
+                                              IConfig const &              config) const
+  {
+    Matches matches(m_filters.size());
+    std::transform(m_filters.begin(), m_filters.end(), matches.begin(), [&](Filter const &filter) {
+      std::vector<TestCase const *> currentMatches;
+      for (auto const &test : testCases)
+        if (isThrowSafe(test, config) && filter.matches(test))
+          currentMatches.emplace_back(&test);
+      return FilterMatch{filter.name(), currentMatches};
+    });
+    return matches;
+  }
 
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
-    {
-        Matches matches( m_filters.size() );
-        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
-            std::vector<TestCase const*> currentMatches;
-            for( auto const& test : testCases )
-                if( isThrowSafe( test, config ) && filter.matches( test ) )
-                    currentMatches.emplace_back( &test );
-            return FilterMatch{ filter.name(), currentMatches };
-        } );
-        return matches;
-    }
+  const TestSpec::vectorStrings &TestSpec::getInvalidArgs() const { return (m_invalidArgs); }
 
-}
+} // namespace Catch
 // end catch_test_spec.cpp
 // start catch_test_spec_parser.cpp
 
 namespace Catch {
 
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        m_substring.reserve(m_arg.size());
-        m_patternName.reserve(m_arg.size());
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-            visitChar( m_arg[m_pos] );
-        endMode();
-        return *this;
+  TestSpecParser::TestSpecParser(ITagAliasRegistry const &tagAliases) : m_tagAliases(&tagAliases) {}
+
+  TestSpecParser &TestSpecParser::parse(std::string const &arg)
+  {
+    m_mode      = None;
+    m_exclusion = false;
+    m_arg       = m_tagAliases->expandAliases(arg);
+    m_escapeChars.clear();
+    m_substring.reserve(m_arg.size());
+    m_patternName.reserve(m_arg.size());
+    m_realPatternPos = 0;
+
+    for (m_pos = 0; m_pos < m_arg.size(); ++m_pos)
+      // if visitChar fails
+      if (!visitChar(m_arg[m_pos])) {
+        m_testSpec.m_invalidArgs.push_back(arg);
+        break;
+      }
+    endMode();
+    return *this;
+  }
+  TestSpec TestSpecParser::testSpec()
+  {
+    addFilter();
+    return m_testSpec;
+  }
+  bool TestSpecParser::visitChar(char c)
+  {
+    if ((m_mode != EscapedName) && (c == '\\')) {
+      escape();
+      addCharToPattern(c);
+      return true;
     }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
+    else if ((m_mode != EscapedName) && (c == ',')) {
+      return separate();
     }
-    void TestSpecParser::visitChar( char c ) {
-        if( c == ',' ) {
-            endMode();
-            addFilter();
-            return;
-        }
 
-        switch( m_mode ) {
-        case None:
-            if( processNoneChar( c ) )
-                return;
-            break;
-        case Name:
-            processNameChar( c );
-            break;
-        case EscapedName:
-            endMode();
-            break;
-        default:
-        case Tag:
-        case QuotedName:
-            if( processOtherChar( c ) )
-                return;
-            break;
-        }
+    switch (m_mode) {
+    case None:
+      if (processNoneChar(c))
+        return true;
+      break;
+    case Name: processNameChar(c); break;
+    case EscapedName:
+      endMode();
+      addCharToPattern(c);
+      return true;
+    default:
+    case Tag:
+    case QuotedName:
+      if (processOtherChar(c))
+        return true;
+      break;
+    }
 
-        m_substring += c;
-        if( !isControlChar( c ) )
-            m_patternName += c;
-    }
-    // Two of the processing methods return true to signal the caller to return
-    // without adding the given character to the current pattern strings
-    bool TestSpecParser::processNoneChar( char c ) {
-        switch( c ) {
-        case ' ':
-            return true;
-        case '~':
-            m_exclusion = true;
-            return false;
-        case '[':
-            startNewMode( Tag );
-            return false;
-        case '"':
-            startNewMode( QuotedName );
-            return false;
-        case '\\':
-            escape();
-            return true;
-        default:
-            startNewMode( Name );
-            return false;
-        }
+    m_substring += c;
+    if (!isControlChar(c)) {
+      m_patternName += c;
+      m_realPatternPos++;
     }
-    void TestSpecParser::processNameChar( char c ) {
-        if( c == '[' ) {
-            if( m_substring == "exclude:" )
-                m_exclusion = true;
-            else
-                endMode();
-            startNewMode( Tag );
-        }
+    return true;
+  }
+  // Two of the processing methods return true to signal the caller to return
+  // without adding the given character to the current pattern strings
+  bool TestSpecParser::processNoneChar(char c)
+  {
+    switch (c) {
+    case ' ': return true;
+    case '~': m_exclusion = true; return false;
+    case '[': startNewMode(Tag); return false;
+    case '"': startNewMode(QuotedName); return false;
+    default: startNewMode(Name); return false;
     }
-    bool TestSpecParser::processOtherChar( char c ) {
-        if( !isControlChar( c ) )
-            return false;
-        m_substring += c;
+  }
+  void TestSpecParser::processNameChar(char c)
+  {
+    if (c == '[') {
+      if (m_substring == "exclude:")
+        m_exclusion = true;
+      else
         endMode();
-        return true;
+      startNewMode(Tag);
     }
-    void TestSpecParser::startNewMode( Mode mode ) {
-        m_mode = mode;
-    }
-    void TestSpecParser::endMode() {
-        switch( m_mode ) {
-        case Name:
-        case QuotedName:
-            return addPattern<TestSpec::NamePattern>();
-        case Tag:
-            return addPattern<TestSpec::TagPattern>();
-        case EscapedName:
-            return startNewMode( Name );
-        case None:
-        default:
-            return startNewMode( None );
-        }
+  }
+  bool TestSpecParser::processOtherChar(char c)
+  {
+    if (!isControlChar(c))
+      return false;
+    m_substring += c;
+    endMode();
+    return true;
+  }
+  void TestSpecParser::startNewMode(Mode mode) { m_mode = mode; }
+  void TestSpecParser::endMode()
+  {
+    switch (m_mode) {
+    case Name:
+    case QuotedName: return addPattern<TestSpec::NamePattern>();
+    case Tag: return addPattern<TestSpec::TagPattern>();
+    case EscapedName: revertBackToLastMode(); return;
+    case None:
+    default: return startNewMode(None);
     }
-    void TestSpecParser::escape() {
-        m_mode = EscapedName;
-        m_escapeChars.push_back( m_pos );
-    }
-    bool TestSpecParser::isControlChar( char c ) const {
-        switch( m_mode ) {
-            default:
-                return false;
-            case None:
-                return c == '~';
-            case Name:
-                return c == '[';
-            case EscapedName:
-                return true;
-            case QuotedName:
-                return c == '"';
-            case Tag:
-                return c == '[' || c == ']';
-        }
+  }
+  void TestSpecParser::escape()
+  {
+    saveLastMode();
+    m_mode = EscapedName;
+    m_escapeChars.push_back(m_realPatternPos);
+  }
+  bool TestSpecParser::isControlChar(char c) const
+  {
+    switch (m_mode) {
+    default: return false;
+    case None: return c == '~';
+    case Name: return c == '[';
+    case EscapedName: return true;
+    case QuotedName: return c == '"';
+    case Tag: return c == '[' || c == ']';
     }
+  }
 
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
+  void TestSpecParser::addFilter()
+  {
+    if (!m_currentFilter.m_patterns.empty()) {
+      m_testSpec.m_filters.push_back(m_currentFilter);
+      m_currentFilter = TestSpec::Filter();
     }
+  }
+
+  void TestSpecParser::saveLastMode() { lastMode = m_mode; }
 
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+  void TestSpecParser::revertBackToLastMode() { m_mode = lastMode; }
+
+  bool TestSpecParser::separate()
+  {
+    if ((m_mode == QuotedName) || (m_mode == Tag)) {
+      // invalid argument, signal failure to previous scope.
+      m_mode = None;
+      m_pos  = m_arg.size();
+      m_substring.clear();
+      m_patternName.clear();
+      return false;
     }
+    endMode();
+    addFilter();
+    return true; // success
+  }
+
+  TestSpec parseTestSpec(std::string const &arg)
+  {
+    return TestSpecParser(ITagAliasRegistry::get()).parse(arg).testSpec();
+  }
 
 } // namespace Catch
 // end catch_test_spec_parser.cpp
@@ -14207,70 +15442,72 @@ static const uint64_t nanosecondsInSecond = 1000000000;
 
 namespace Catch {
 
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    namespace {
-        auto estimateClockResolution() -> uint64_t {
-            uint64_t sum = 0;
-            static const uint64_t iterations = 1000000;
-
-            auto startTime = getCurrentNanosecondsSinceEpoch();
-
-            for( std::size_t i = 0; i < iterations; ++i ) {
+  auto getCurrentNanosecondsSinceEpoch() -> uint64_t
+  {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+               std::chrono::high_resolution_clock::now().time_since_epoch())
+        .count();
+  }
 
-                uint64_t ticks;
-                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-                do {
-                    ticks = getCurrentNanosecondsSinceEpoch();
-                } while( ticks == baseTicks );
+  namespace {
+    auto estimateClockResolution() -> uint64_t
+    {
+      uint64_t              sum        = 0;
+      static const uint64_t iterations = 1000000;
 
-                auto delta = ticks - baseTicks;
-                sum += delta;
+      auto startTime = getCurrentNanosecondsSinceEpoch();
 
-                // If we have been calibrating for over 3 seconds -- the clock
-                // is terrible and we should move on.
-                // TBD: How to signal that the measured resolution is probably wrong?
-                if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / ( i + 1u );
-                }
-            }
+      for (std::size_t i = 0; i < iterations; ++i) {
 
-            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-            // - and potentially do more iterations if there's a high variance.
-            return sum/iterations;
-        }
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
+        uint64_t ticks;
+        uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+        do {
+          ticks = getCurrentNanosecondsSinceEpoch();
+        } while (ticks == baseTicks);
+
+        auto delta = ticks - baseTicks;
+        sum += delta;
+
+        // If we have been calibrating for over 3 seconds -- the clock
+        // is terrible and we should move on.
+        // TBD: How to signal that the measured resolution is probably wrong?
+        if (ticks > startTime + 3 * nanosecondsInSecond) {
+          return sum / (i + 1u);
+        }
+      }
+
+      // We're just taking the mean, here. To do better we could take the std. dev and exclude
+      // outliers
+      // - and potentially do more iterations if there's a high variance.
+      return sum / iterations;
+    }
+  } // namespace
+  auto getEstimatedClockResolution() -> uint64_t
+  {
+    static auto s_resolution = estimateClockResolution();
+    return s_resolution;
+  }
 
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
+  void Timer::start() { m_nanoseconds = getCurrentNanosecondsSinceEpoch(); }
+  auto Timer::getElapsedNanoseconds() const -> uint64_t
+  {
+    return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+  }
+  auto Timer::getElapsedMicroseconds() const -> uint64_t { return getElapsedNanoseconds() / 1000; }
+  auto Timer::getElapsedMilliseconds() const -> unsigned int
+  {
+    return static_cast<unsigned int>(getElapsedMicroseconds() / 1000);
+  }
+  auto Timer::getElapsedSeconds() const -> double { return getElapsedMicroseconds() / 1000000.0; }
 
 } // namespace Catch
 // end catch_timer.cpp
 // start catch_tostring.cpp
 
 #if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wglobal-constructors"
 #endif
 
 // Enable specific decls locally
@@ -14283,239 +15520,256 @@ namespace Catch {
 
 namespace Catch {
 
-namespace Detail {
+  namespace Detail {
 
     const std::string unprintableString = "{?}";
 
     namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
+      const int hexThreshold = 255;
 
-            static Arch which() {
-                union _{
-                    int asInt;
-                    char asChar[sizeof (int)];
-                } u;
+      struct Endianness
+      {
+        enum Arch { Big, Little };
 
-                u.asInt = 1;
-                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
-            }
-        };
-    }
+        static Arch which()
+        {
+          union _ {
+            int  asInt;
+            char asChar[sizeof(int)];
+          } u;
 
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
+          u.asInt = 1;
+          return (u.asChar[sizeof(int) - 1] == 1) ? Big : Little;
         }
+      };
+    } // namespace
 
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
+    std::string rawMemoryToString(const void *object, std::size_t size)
+    {
+      // Reverse order for little endian architectures
+      int i = 0, end = static_cast<int>(size), inc = 1;
+      if (Endianness::which() == Endianness::Little) {
+        i   = end - 1;
+        end = inc = -1;
+      }
+
+      unsigned char const *bytes = static_cast<unsigned char const *>(object);
+      ReusableStringStream rss;
+      rss << "0x" << std::setfill('0') << std::hex;
+      for (; i != end; i += inc)
+        rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+      return rss.str();
+    }
+  } // namespace Detail
+
+  template <typename T> std::string fpToString(T value, int precision)
+  {
     if (Catch::isnan(value)) {
-        return "nan";
+      return "nan";
     }
 
     ReusableStringStream rss;
-    rss << std::setprecision( precision )
-        << std::fixed
-        << value;
+    rss << std::setprecision(precision) << std::fixed << value;
     std::string d = rss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
+    std::size_t i = d.find_last_not_of('0');
+    if (i != std::string::npos && i != d.size() - 1) {
+      if (d[i] == '.')
+        i++;
+      d = d.substr(0, i + 1);
     }
     return d;
-}
+  }
 
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
+  //// ======================================================= ////
+  //
+  //   Out-of-line defs for full specialization of StringMaker
+  //
+  //// ======================================================= ////
 
-std::string StringMaker<std::string>::convert(const std::string& str) {
+  std::string StringMaker<std::string>::convert(const std::string &str)
+  {
     if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
+      return '"' + str + '"';
     }
 
     std::string s("\"");
     for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
+      switch (c) {
+      case '\n': s.append("\\n"); break;
+      case '\t': s.append("\\t"); break;
+      default: s.push_back(c); break;
+      }
     }
     s.append("\"");
     return s;
-}
+  }
 
 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return ::Catch::Detail::stringify(std::string{ str });
-}
+  std::string StringMaker<std::string_view>::convert(std::string_view str)
+  {
+    return ::Catch::Detail::stringify(std::string{str});
+  }
 #endif
 
-std::string StringMaker<char const*>::convert(char const* str) {
+  std::string StringMaker<char const *>::convert(char const *str)
+  {
     if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
+      return ::Catch::Detail::stringify(std::string{str});
     }
-}
-std::string StringMaker<char*>::convert(char* str) {
+    else {
+      return {"{null string}"};
+    }
+  }
+  std::string StringMaker<char *>::convert(char *str)
+  {
     if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
+      return ::Catch::Detail::stringify(std::string{str});
     }
-}
+    else {
+      return {"{null string}"};
+    }
+  }
 
 #ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+  std::string StringMaker<std::wstring>::convert(const std::wstring &wstr)
+  {
     std::string s;
     s.reserve(wstr.size());
     for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+      s += (c <= 0xff) ? static_cast<char>(c) : '?';
     }
     return ::Catch::Detail::stringify(s);
-}
+  }
 
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+  std::string StringMaker<std::wstring_view>::convert(std::wstring_view str)
+  {
     return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
+  }
+#endif
 
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+  std::string StringMaker<wchar_t const *>::convert(wchar_t const *str)
+  {
     if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
+      return ::Catch::Detail::stringify(std::wstring{str});
     }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    else {
+      return {"{null string}"};
+    }
+  }
+  std::string StringMaker<wchar_t *>::convert(wchar_t *str)
+  {
     if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
+      return ::Catch::Detail::stringify(std::wstring{str});
     }
-}
+    else {
+      return {"{null string}"};
+    }
+  }
 #endif
 
 #if defined(CATCH_CONFIG_CPP17_BYTE)
 #include <cstddef>
-std::string StringMaker<std::byte>::convert(std::byte value) {
+  std::string StringMaker<std::byte>::convert(std::byte value)
+  {
     return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
-}
+  }
 #endif // defined(CATCH_CONFIG_CPP17_BYTE)
 
-std::string StringMaker<int>::convert(int value) {
+  std::string StringMaker<int>::convert(int value)
+  {
     return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
+  }
+  std::string StringMaker<long>::convert(long value)
+  {
     return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
+  }
+  std::string StringMaker<long long>::convert(long long value)
+  {
     ReusableStringStream rss;
     rss << value;
     if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
+      rss << " (0x" << std::hex << value << ')';
     }
     return rss.str();
-}
+  }
 
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
+  std::string StringMaker<unsigned int>::convert(unsigned int value)
+  {
     return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
+  }
+  std::string StringMaker<unsigned long>::convert(unsigned long value)
+  {
     return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+  }
+  std::string StringMaker<unsigned long long>::convert(unsigned long long value)
+  {
     ReusableStringStream rss;
     rss << value;
     if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
+      rss << " (0x" << std::hex << value << ')';
     }
     return rss.str();
-}
+  }
 
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
+  std::string StringMaker<bool>::convert(bool b) { return b ? "true" : "false"; }
 
-std::string StringMaker<signed char>::convert(signed char value) {
+  std::string StringMaker<signed char>::convert(signed char value)
+  {
     if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
+      return "'\\r'";
     }
-}
-std::string StringMaker<char>::convert(char c) {
+    else if (value == '\f') {
+      return "'\\f'";
+    }
+    else if (value == '\n') {
+      return "'\\n'";
+    }
+    else if (value == '\t') {
+      return "'\\t'";
+    }
+    else if ('\0' <= value && value < ' ') {
+      return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    }
+    else {
+      char chstr[] = "' '";
+      chstr[1]     = value;
+      return chstr;
+    }
+  }
+  std::string StringMaker<char>::convert(char c)
+  {
     return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
+  }
+  std::string StringMaker<unsigned char>::convert(unsigned char c)
+  {
     return ::Catch::Detail::stringify(static_cast<char>(c));
-}
+  }
 
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
+  std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) { return "nullptr"; }
 
-int StringMaker<float>::precision = 5;
+  int StringMaker<float>::precision = 5;
 
-std::string StringMaker<float>::convert(float value) {
+  std::string StringMaker<float>::convert(float value)
+  {
     return fpToString(value, precision) + 'f';
-}
+  }
 
-int StringMaker<double>::precision = 10;
+  int StringMaker<double>::precision = 10;
 
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, precision);
-}
+  std::string StringMaker<double>::convert(double value) { return fpToString(value, precision); }
 
-std::string ratio_string<std::atto>::symbol() { return "a"; }
-std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string ratio_string<std::pico>::symbol() { return "p"; }
-std::string ratio_string<std::nano>::symbol() { return "n"; }
-std::string ratio_string<std::micro>::symbol() { return "u"; }
-std::string ratio_string<std::milli>::symbol() { return "m"; }
+  std::string ratio_string<std::atto>::symbol() { return "a"; }
+  std::string ratio_string<std::femto>::symbol() { return "f"; }
+  std::string ratio_string<std::pico>::symbol() { return "p"; }
+  std::string ratio_string<std::nano>::symbol() { return "n"; }
+  std::string ratio_string<std::micro>::symbol() { return "u"; }
+  std::string ratio_string<std::milli>::symbol() { return "m"; }
 
 } // end namespace Catch
 
 #if defined(__clang__)
-#    pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #endif
 
 // end catch_tostring.cpp
@@ -14523,67 +15777,67 @@ std::string ratio_string<std::milli>::symbol() { return "m"; }
 
 namespace Catch {
 
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
+  Counts Counts::operator-(Counts const &other) const
+  {
+    Counts diff;
+    diff.passed      = passed - other.passed;
+    diff.failed      = failed - other.failed;
+    diff.failedButOk = failedButOk - other.failedButOk;
+    return diff;
+  }
 
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
+  Counts &Counts::operator+=(Counts const &other)
+  {
+    passed += other.passed;
+    failed += other.failed;
+    failedButOk += other.failedButOk;
+    return *this;
+  }
 
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
+  std::size_t Counts::total() const { return passed + failed + failedButOk; }
+  bool        Counts::allPassed() const { return failed == 0 && failedButOk == 0; }
+  bool        Counts::allOk() const { return failed == 0; }
 
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
+  Totals Totals::operator-(Totals const &other) const
+  {
+    Totals diff;
+    diff.assertions = assertions - other.assertions;
+    diff.testCases  = testCases - other.testCases;
+    return diff;
+  }
 
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
+  Totals &Totals::operator+=(Totals const &other)
+  {
+    assertions += other.assertions;
+    testCases += other.testCases;
+    return *this;
+  }
 
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
+  Totals Totals::delta(Totals const &prevTotals) const
+  {
+    Totals diff = *this - prevTotals;
+    if (diff.assertions.failed > 0)
+      ++diff.testCases.failed;
+    else if (diff.assertions.failedButOk > 0)
+      ++diff.testCases.failedButOk;
+    else
+      ++diff.testCases.passed;
+    return diff;
+  }
 
-}
+} // namespace Catch
 // end catch_totals.cpp
 // start catch_uncaught_exceptions.cpp
 
 #include <exception>
 
 namespace Catch {
-    bool uncaught_exceptions() {
+  bool uncaught_exceptions()
+  {
 #if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
+    return std::uncaught_exceptions() > 0;
 #else
-        return std::uncaught_exception();
+    return std::uncaught_exception();
 #endif
   }
 } // end namespace Catch
@@ -14594,78 +15848,66 @@ namespace Catch {
 
 namespace Catch {
 
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
+  Version::Version(unsigned int _majorVersion, unsigned int _minorVersion,
+                   unsigned int _patchNumber, char const *const _branchName,
+                   unsigned int _buildNumber)
+      : majorVersion(_majorVersion), minorVersion(_minorVersion), patchNumber(_patchNumber),
+        branchName(_branchName), buildNumber(_buildNumber)
+  {
+  }
 
-    Version const& libraryVersion() {
-        static Version version( 2, 9, 2, "", 0 );
-        return version;
+  std::ostream &operator<<(std::ostream &os, Version const &version)
+  {
+    os << version.majorVersion << '.' << version.minorVersion << '.' << version.patchNumber;
+    // branchName is never null -> 0th char is \0 if it is empty
+    if (version.branchName[0]) {
+      os << '-' << version.branchName << '.' << version.buildNumber;
     }
+    return os;
+  }
 
-}
+  Version const &libraryVersion()
+  {
+    static Version version(2, 10, 2, "", 0);
+    return version;
+  }
+
+} // namespace Catch
 // end catch_version.cpp
 // start catch_wildcard_pattern.cpp
 
-#include <sstream>
-
 namespace Catch {
 
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( adjustCase( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
+  WildcardPattern::WildcardPattern(std::string const &   pattern,
+                                   CaseSensitive::Choice caseSensitivity)
+      : m_caseSensitivity(caseSensitivity), m_pattern(normaliseString(pattern))
+  {
+    if (startsWith(m_pattern, '*')) {
+      m_pattern  = m_pattern.substr(1);
+      m_wildcard = WildcardAtStart;
+    }
+    if (endsWith(m_pattern, '*')) {
+      m_pattern  = m_pattern.substr(0, m_pattern.size() - 1);
+      m_wildcard = static_cast<WildcardPosition>(m_wildcard | WildcardAtEnd);
     }
+  }
 
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == adjustCase( str );
-            case WildcardAtStart:
-                return endsWith( adjustCase( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( adjustCase( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( adjustCase( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
+  bool WildcardPattern::matches(std::string const &str) const
+  {
+    switch (m_wildcard) {
+    case NoWildcard: return m_pattern == normaliseString(str);
+    case WildcardAtStart: return endsWith(normaliseString(str), m_pattern);
+    case WildcardAtEnd: return startsWith(normaliseString(str), m_pattern);
+    case WildcardAtBothEnds: return contains(normaliseString(str), m_pattern);
+    default: CATCH_INTERNAL_ERROR("Unknown enum");
     }
+  }
 
-    std::string WildcardPattern::adjustCase( std::string const& str ) const {
-        return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
-    }
-}
+  std::string WildcardPattern::normaliseString(std::string const &str) const
+  {
+    return trim(m_caseSensitivity == CaseSensitive::No ? toLower(str) : str);
+  }
+} // namespace Catch
 // end catch_wildcard_pattern.cpp
 // start catch_xmlwriter.cpp
 
@@ -14675,335 +15917,342 @@ using uchar = unsigned char;
 
 namespace Catch {
 
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
+  namespace {
 
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
+    size_t trailingBytes(unsigned char c)
+    {
+      if ((c & 0xE0) == 0xC0) {
+        return 2;
+      }
+      if ((c & 0xF0) == 0xE0) {
+        return 3;
+      }
+      if ((c & 0xF8) == 0xF0) {
+        return 4;
+      }
+      CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c)
+    {
+      if ((c & 0xE0) == 0xC0) {
+        return c & 0x1F;
+      }
+      if ((c & 0xF0) == 0xE0) {
+        return c & 0x0F;
+      }
+      if ((c & 0xF8) == 0xF0) {
+        return c & 0x07;
+      }
+      CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream &os, unsigned char c)
+    {
+      std::ios_base::fmtflags f(os.flags());
+      os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+         << static_cast<int>(c);
+      os.flags(f);
     }
 
-} // anonymous namespace
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            uchar c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
+  } // anonymous namespace
 
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
+  XmlEncode::XmlEncode(std::string const &str, ForWhat forWhat) : m_str(str), m_forWhat(forWhat) {}
 
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
+  void XmlEncode::encodeTo(std::ostream &os) const
+  {
+    // Apostrophe escaping not necessary if we always use " to write attributes
+    // (see: http://www.w3.org/TR/xml/#syntax)
 
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    uchar nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
+    for (std::size_t idx = 0; idx < m_str.size(); ++idx) {
+      uchar c = m_str[idx];
+      switch (c) {
+      case '<': os << "&lt;"; break;
+      case '&': os << "&amp;"; break;
 
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
+      case '>':
+        // See: http://www.w3.org/TR/xml/#syntax
+        if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+          os << "&gt;";
+        else
+          os << c;
+        break;
 
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
+      case '\"':
+        if (m_forWhat == ForAttributes)
+          os << "&quot;";
+        else
+          os << c;
+        break;
+
+      default:
+        // Check for control characters and invalid utf-8
+
+        // Escape control characters in standard ascii
+        // see
+        // http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+        if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+          hexEscapeChar(os, c);
+          break;
+        }
+
+        // Plain ASCII: Write it to stream
+        if (c < 0x7F) {
+          os << c;
+          break;
+        }
+
+        // UTF-8 territory
+        // Check if the encoding is valid and if it is not, hex escape bytes.
+        // Important: We do not check the exact decoded values for validity, only the encoding
+        // format First check that this bytes is a valid lead byte: This means that it is not
+        // encoded as 1111 1XXX Or as 10XX XXXX
+        if (c < 0xC0 || c >= 0xF8) {
+          hexEscapeChar(os, c);
+          break;
+        }
+
+        auto encBytes = trailingBytes(c);
+        // Are there enough bytes left to avoid accessing out-of-bounds memory?
+        if (idx + encBytes - 1 >= m_str.size()) {
+          hexEscapeChar(os, c);
+          break;
+        }
+        // The header is valid, check data
+        // The next encBytes bytes must together be a valid utf-8
+        // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+        bool     valid = true;
+        uint32_t value = headerValue(c);
+        for (std::size_t n = 1; n < encBytes; ++n) {
+          uchar nc = m_str[idx + n];
+          valid &= ((nc & 0xC0) == 0x80);
+          value = (value << 6) | (nc & 0x3F);
+        }
+
+        if (
+            // Wrong bit pattern of following bytes
+            (!valid) ||
+            // Overlong encodings
+            (value < 0x80) || (0x80 <= value && value < 0x800 && encBytes > 2) ||
+            (0x800 < value && value < 0x10000 && encBytes > 3) ||
+            // Encoded value out of range
+            (value >= 0x110000)) {
+          hexEscapeChar(os, c);
+          break;
+        }
+
+        // If we got here, this is in fact a valid(ish) utf-8 sequence
+        for (std::size_t n = 0; n < encBytes; ++n) {
+          os << m_str[idx + n];
+        }
+        idx += encBytes - 1;
+        break;
+      }
     }
+  }
 
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
+  std::ostream &operator<<(std::ostream &os, XmlEncode const &xmlEncode)
+  {
+    xmlEncode.encodeTo(os);
+    return os;
+  }
 
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
-    :   m_writer( writer )
-    {}
+  XmlWriter::ScopedElement::ScopedElement(XmlWriter *writer) : m_writer(writer) {}
 
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ){
-        other.m_writer = nullptr;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        return *this;
-    }
+  XmlWriter::ScopedElement::ScopedElement(ScopedElement &&other) noexcept : m_writer(other.m_writer)
+  {
+    other.m_writer = nullptr;
+  }
+  XmlWriter::ScopedElement &XmlWriter::ScopedElement::operator=(ScopedElement &&other) noexcept
+  {
+    if (m_writer) {
+      m_writer->endElement();
+    }
+    m_writer       = other.m_writer;
+    other.m_writer = nullptr;
+    return *this;
+  }
 
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if( m_writer )
-            m_writer->endElement();
-    }
+  XmlWriter::ScopedElement::~ScopedElement()
+  {
+    if (m_writer)
+      m_writer->endElement();
+  }
 
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
-        m_writer->writeText( text, indent );
-        return *this;
-    }
+  XmlWriter::ScopedElement &XmlWriter::ScopedElement::writeText(std::string const &text,
+                                                                bool               indent)
+  {
+    m_writer->writeText(text, indent);
+    return *this;
+  }
 
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
+  XmlWriter::XmlWriter(std::ostream &os) : m_os(os) { writeDeclaration(); }
 
-    XmlWriter::~XmlWriter() {
-        while( !m_tags.empty() )
-            endElement();
-    }
+  XmlWriter::~XmlWriter()
+  {
+    while (!m_tags.empty())
+      endElement();
+  }
 
-    XmlWriter& XmlWriter::startElement( std::string const& name ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        m_os << m_indent << '<' << name;
-        m_tags.push_back( name );
-        m_indent += "  ";
-        m_tagIsOpen = true;
-        return *this;
-    }
+  XmlWriter &XmlWriter::startElement(std::string const &name)
+  {
+    ensureTagClosed();
+    newlineIfNecessary();
+    m_os << m_indent << '<' << name;
+    m_tags.push_back(name);
+    m_indent += "  ";
+    m_tagIsOpen = true;
+    return *this;
+  }
 
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
-        ScopedElement scoped( this );
-        startElement( name );
-        return scoped;
-    }
+  XmlWriter::ScopedElement XmlWriter::scopedElement(std::string const &name)
+  {
+    ScopedElement scoped(this);
+    startElement(name);
+    return scoped;
+  }
 
-    XmlWriter& XmlWriter::endElement() {
-        newlineIfNecessary();
-        m_indent = m_indent.substr( 0, m_indent.size()-2 );
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        }
-        else {
-            m_os << m_indent << "</" << m_tags.back() << ">";
-        }
-        m_os << std::endl;
-        m_tags.pop_back();
-        return *this;
+  XmlWriter &XmlWriter::endElement()
+  {
+    newlineIfNecessary();
+    m_indent = m_indent.substr(0, m_indent.size() - 2);
+    if (m_tagIsOpen) {
+      m_os << "/>";
+      m_tagIsOpen = false;
     }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
+    else {
+      m_os << m_indent << "</" << m_tags.back() << ">";
     }
+    m_os << std::endl;
+    m_tags.pop_back();
+    return *this;
+  }
 
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
+  XmlWriter &XmlWriter::writeAttribute(std::string const &name, std::string const &attribute)
+  {
+    if (!name.empty() && !attribute.empty())
+      m_os << ' ' << name << "=\"" << XmlEncode(attribute, XmlEncode::ForAttributes) << '"';
+    return *this;
+  }
 
-    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if( tagWasOpen && indent )
-                m_os << m_indent;
-            m_os << XmlEncode( text );
-            m_needsNewline = true;
-        }
-        return *this;
-    }
+  XmlWriter &XmlWriter::writeAttribute(std::string const &name, bool attribute)
+  {
+    m_os << ' ' << name << "=\"" << (attribute ? "true" : "false") << '"';
+    return *this;
+  }
 
-    XmlWriter& XmlWriter::writeComment( std::string const& text ) {
-        ensureTagClosed();
-        m_os << m_indent << "<!--" << text << "-->";
-        m_needsNewline = true;
-        return *this;
-    }
+  XmlWriter &XmlWriter::writeText(std::string const &text, bool indent)
+  {
+    if (!text.empty()) {
+      bool tagWasOpen = m_tagIsOpen;
+      ensureTagClosed();
+      if (tagWasOpen && indent)
+        m_os << m_indent;
+      m_os << XmlEncode(text);
+      m_needsNewline = true;
+    }
+    return *this;
+  }
 
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
+  XmlWriter &XmlWriter::writeComment(std::string const &text)
+  {
+    ensureTagClosed();
+    m_os << m_indent << "<!--" << text << "-->";
+    m_needsNewline = true;
+    return *this;
+  }
 
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
+  void XmlWriter::writeStylesheetRef(std::string const &url)
+  {
+    m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+  }
 
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << ">" << std::endl;
-            m_tagIsOpen = false;
-        }
-    }
+  XmlWriter &XmlWriter::writeBlankLine()
+  {
+    ensureTagClosed();
+    m_os << '\n';
+    return *this;
+  }
 
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  void XmlWriter::ensureTagClosed()
+  {
+    if (m_tagIsOpen) {
+      m_os << ">" << std::endl;
+      m_tagIsOpen = false;
     }
+  }
 
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
+  void XmlWriter::writeDeclaration() { m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; }
+
+  void XmlWriter::newlineIfNecessary()
+  {
+    if (m_needsNewline) {
+      m_os << std::endl;
+      m_needsNewline = false;
     }
-}
+  }
+} // namespace Catch
 // end catch_xmlwriter.cpp
 // start catch_reporter_bases.cpp
 
-#include <cstring>
+#include <cassert>
 #include <cfloat>
 #include <cstdio>
-#include <cassert>
+#include <cstring>
 #include <memory>
 
 namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
-
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
+  void prepareExpandedExpression(AssertionResult &result) { result.getExpandedExpression(); }
+
+  // Because formatting using c++ streams is stateful, drop down to C is required
+  // Alternatively we could use stringstream, but its performance is... not good.
+  std::string getFormattedDuration(double duration)
+  {
+    // Max exponent + 1 is required to represent the whole part
+    // + 1 for decimal point
+    // + 3 for the 3 decimal places
+    // + 1 for null terminator
+    const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+    char              buffer[maxDoubleSize];
+
+    // Save previous errno, to prevent sprintf from overwriting it
+    ErrnoGuard guard;
 #ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
+    sprintf_s(buffer, "%.3f", duration);
 #else
-        std::sprintf(buffer, "%.3f", duration);
+    std::sprintf(buffer, "%.3f", duration);
 #endif
-        return std::string(buffer);
-    }
+    return std::string(buffer);
+  }
 
-    std::string serializeFilters( std::vector<std::string> const& container ) {
-        ReusableStringStream oss;
-        bool first = true;
-        for (auto&& filter : container)
-        {
-            if (!first)
-                oss << ' ';
-            else
-                first = false;
+  std::string serializeFilters(std::vector<std::string> const &container)
+  {
+    ReusableStringStream oss;
+    bool                 first = true;
+    for (auto &&filter : container) {
+      if (!first)
+        oss << ' ';
+      else
+        first = false;
 
-            oss << filter;
-        }
-        return oss.str();
+      oss << filter;
     }
+    return oss.str();
+  }
 
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
+  TestEventListenerBase::TestEventListenerBase(ReporterConfig const &_config)
+      : StreamingReporterBase(_config)
+  {
+  }
 
-    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
-        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
-    }
+  std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities()
+  {
+    return {Verbosity::Quiet, Verbosity::Normal, Verbosity::High};
+  }
 
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+  void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
 
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
+  bool TestEventListenerBase::assertionEnded(AssertionStats const &) { return false; }
 
 } // end namespace Catch
 // end catch_reporter_bases.cpp
@@ -15012,281 +16261,293 @@ namespace Catch {
 namespace {
 
 #ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
+  const char *failedString() { return "FAILED"; }
+  const char *passedString() { return "PASSED"; }
 #else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
+  const char *failedString() { return "failed"; }
+  const char *passedString() { return "passed"; }
 #endif
 
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+  // Colour::LightGrey
+  Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
 
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
+  std::string bothOrAll(std::size_t count)
+  {
+    return count == 1 ? std::string() : count == 2 ? "both " : "all ";
+  }
 
-} // anon namespace
+} // namespace
 
 namespace Catch {
-namespace {
-// Colour, message variants:
-// - white: No tests ran.
-// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// -   red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals) {
-    if (totals.testCases.total() == 0) {
+  namespace {
+    // Colour, message variants:
+    // - white: No tests ran.
+    // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+    // - white: Passed [both/all] N test cases (no assertions).
+    // -   red: Failed N tests cases, failed M assertions.
+    // - green: Passed [both/all] N tests cases with M assertions.
+    void printTotals(std::ostream &out, const Totals &totals)
+    {
+      if (totals.testCases.total() == 0) {
         out << "No tests ran.";
-    } else if (totals.testCases.failed == totals.testCases.total()) {
-        Colour colour(Colour::ResultError);
+      }
+      else if (totals.testCases.failed == totals.testCases.total()) {
+        Colour            colour(Colour::ResultError);
         const std::string qualify_assertions_failed =
-            totals.assertions.failed == totals.assertions.total() ?
-            bothOrAll(totals.assertions.failed) : std::string();
-        out <<
-            "Failed " << bothOrAll(totals.testCases.failed)
-            << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << qualify_assertions_failed <<
-            pluralise(totals.assertions.failed, "assertion") << '.';
-    } else if (totals.assertions.total() == 0) {
-        out <<
-            "Passed " << bothOrAll(totals.testCases.total())
-            << pluralise(totals.testCases.total(), "test case")
-            << " (no assertions).";
-    } else if (totals.assertions.failed) {
+            totals.assertions.failed == totals.assertions.total()
+                ? bothOrAll(totals.assertions.failed)
+                : std::string();
+        out << "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case")
+            << ", "
+               "failed "
+            << qualify_assertions_failed << pluralise(totals.assertions.failed, "assertion") << '.';
+      }
+      else if (totals.assertions.total() == 0) {
+        out << "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case") << " (no assertions).";
+      }
+      else if (totals.assertions.failed) {
         Colour colour(Colour::ResultError);
-        out <<
-            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
-    } else {
+        out << "Failed " << pluralise(totals.testCases.failed, "test case")
+            << ", "
+               "failed "
+            << pluralise(totals.assertions.failed, "assertion") << '.';
+      }
+      else {
         Colour colour(Colour::ResultSuccess);
-        out <<
-            "Passed " << bothOrAll(totals.testCases.passed)
-            << pluralise(totals.testCases.passed, "test case") <<
-            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
+        out << "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case") << " with "
+            << pluralise(totals.assertions.passed, "assertion") << '.';
+      }
     }
-}
 
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages) {}
-
-    void print() {
+    // Implementation of CompactReporter formatting
+    class AssertionPrinter
+    {
+    public:
+      AssertionPrinter &operator=(AssertionPrinter const &) = delete;
+      AssertionPrinter(AssertionPrinter const &)            = delete;
+      AssertionPrinter(std::ostream &_stream, AssertionStats const &_stats, bool _printInfoMessages)
+          : stream(_stream), result(_stats.assertionResult), messages(_stats.infoMessages),
+            itMessage(_stats.infoMessages.begin()), printInfoMessages(_printInfoMessages)
+      {
+      }
+
+      void print()
+      {
         printSourceInfo();
 
         itMessage = messages.begin();
 
         switch (result.getResultType()) {
         case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, passedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
-            else
-                printResultType(Colour::Error, failedString());
-            printOriginalExpression();
-            printReconstructedExpression();
+          printResultType(Colour::ResultSuccess, passedString());
+          printOriginalExpression();
+          printReconstructedExpression();
+          if (!result.hasExpression())
+            printRemainingMessages(Colour::None);
+          else
             printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
+          break;
+        case ResultWas::ExpressionFailed:
+          if (result.isOk())
+            printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+          else
             printResultType(Colour::Error, failedString());
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
+          printOriginalExpression();
+          printReconstructedExpression();
+          printRemainingMessages();
+          break;
+        case ResultWas::ThrewException:
+          printResultType(Colour::Error, failedString());
+          printIssue("unexpected exception with message:");
+          printMessage();
+          printExpressionWas();
+          printRemainingMessages();
+          break;
         case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, failedString());
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
+          printResultType(Colour::Error, failedString());
+          printIssue("fatal error condition with message:");
+          printMessage();
+          printExpressionWas();
+          printRemainingMessages();
+          break;
         case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, failedString());
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
+          printResultType(Colour::Error, failedString());
+          printIssue("expected exception, got none");
+          printExpressionWas();
+          printRemainingMessages();
+          break;
         case ResultWas::Info:
-            printResultType(Colour::None, "info");
-            printMessage();
-            printRemainingMessages();
-            break;
+          printResultType(Colour::None, "info");
+          printMessage();
+          printRemainingMessages();
+          break;
         case ResultWas::Warning:
-            printResultType(Colour::None, "warning");
-            printMessage();
-            printRemainingMessages();
-            break;
+          printResultType(Colour::None, "warning");
+          printMessage();
+          printRemainingMessages();
+          break;
         case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, failedString());
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-            // These cases are here to prevent compiler warnings
+          printResultType(Colour::Error, failedString());
+          printIssue("explicitly");
+          printRemainingMessages(Colour::None);
+          break;
+          // These cases are here to prevent compiler warnings
         case ResultWas::Unknown:
         case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
+        case ResultWas::Exception: printResultType(Colour::Error, "** internal error **"); break;
         }
-    }
+      }
 
-private:
-    void printSourceInfo() const {
+    private:
+      void printSourceInfo() const
+      {
         Colour colourGuard(Colour::FileName);
         stream << result.getSourceInfo() << ':';
-    }
+      }
 
-    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+      void printResultType(Colour::Code colour, std::string const &passOrFail) const
+      {
         if (!passOrFail.empty()) {
-            {
-                Colour colourGuard(colour);
-                stream << ' ' << passOrFail;
-            }
-            stream << ':';
+          {
+            Colour colourGuard(colour);
+            stream << ' ' << passOrFail;
+          }
+          stream << ':';
         }
-    }
+      }
 
-    void printIssue(std::string const& issue) const {
-        stream << ' ' << issue;
-    }
+      void printIssue(std::string const &issue) const { stream << ' ' << issue; }
 
-    void printExpressionWas() {
+      void printExpressionWas()
+      {
         if (result.hasExpression()) {
-            stream << ';';
-            {
-                Colour colour(dimColour());
-                stream << " expression was:";
-            }
-            printOriginalExpression();
+          stream << ';';
+          {
+            Colour colour(dimColour());
+            stream << " expression was:";
+          }
+          printOriginalExpression();
         }
-    }
+      }
 
-    void printOriginalExpression() const {
+      void printOriginalExpression() const
+      {
         if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
+          stream << ' ' << result.getExpression();
         }
-    }
+      }
 
-    void printReconstructedExpression() const {
+      void printReconstructedExpression() const
+      {
         if (result.hasExpandedExpression()) {
-            {
-                Colour colour(dimColour());
-                stream << " for: ";
-            }
-            stream << result.getExpandedExpression();
+          {
+            Colour colour(dimColour());
+            stream << " for: ";
+          }
+          stream << result.getExpandedExpression();
         }
-    }
+      }
 
-    void printMessage() {
+      void printMessage()
+      {
         if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
+          stream << " '" << itMessage->message << '\'';
+          ++itMessage;
         }
-    }
+      }
 
-    void printRemainingMessages(Colour::Code colour = dimColour()) {
+      void printRemainingMessages(Colour::Code colour = dimColour())
+      {
         if (itMessage == messages.end())
-            return;
+          return;
 
         const auto itEnd = messages.cend();
-        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+        const auto N     = static_cast<std::size_t>(std::distance(itMessage, itEnd));
 
         {
-            Colour colourGuard(colour);
-            stream << " with " << pluralise(N, "message") << ':';
+          Colour colourGuard(colour);
+          stream << " with " << pluralise(N, "message") << ':';
         }
 
         while (itMessage != itEnd) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                printMessage();
-                if (itMessage != itEnd) {
-                    Colour colourGuard(dimColour());
-                    stream << " and";
-                }
-                continue;
+          // If this assertion is a warning ignore any INFO messages
+          if (printInfoMessages || itMessage->type != ResultWas::Info) {
+            printMessage();
+            if (itMessage != itEnd) {
+              Colour colourGuard(dimColour());
+              stream << " and";
             }
-            ++itMessage;
+            continue;
+          }
+          ++itMessage;
         }
-    }
+      }
 
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-};
+    private:
+      std::ostream &                           stream;
+      AssertionResult const &                  result;
+      std::vector<MessageInfo>                 messages;
+      std::vector<MessageInfo>::const_iterator itMessage;
+      bool                                     printInfoMessages;
+    };
 
-} // anon namespace
+  } // namespace
 
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
+  std::string CompactReporter::getDescription()
+  {
+    return "Reports test results on a single line, suitable for IDEs";
+  }
 
-        ReporterPreferences CompactReporter::getPreferences() const {
-            return m_reporterPrefs;
-        }
+  ReporterPreferences CompactReporter::getPreferences() const { return m_reporterPrefs; }
 
-        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
+  void CompactReporter::noMatchingTestCases(std::string const &spec)
+  {
+    stream << "No test cases matched '" << spec << '\'' << std::endl;
+  }
 
-        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
+  void CompactReporter::assertionStarting(AssertionInfo const &) {}
 
-        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
+  bool CompactReporter::assertionEnded(AssertionStats const &_assertionStats)
+  {
+    AssertionResult const &result = _assertionStats.assertionResult;
 
-            bool printInfoMessages = true;
+    bool printInfoMessages = true;
 
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
+    // Drop out if result was successful and we're not printing those
+    if (!m_config->includeSuccessfulResults() && result.isOk()) {
+      if (result.getResultType() != ResultWas::Warning)
+        return false;
+      printInfoMessages = false;
+    }
 
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
+    AssertionPrinter printer(stream, _assertionStats, printInfoMessages);
+    printer.print();
 
-            stream << std::endl;
-            return true;
-        }
+    stream << std::endl;
+    return true;
+  }
 
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
+  void CompactReporter::sectionEnded(SectionStats const &_sectionStats)
+  {
+    if (m_config->showDurations() == ShowDurations::Always) {
+      stream << getFormattedDuration(_sectionStats.durationInSeconds)
+             << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    }
+  }
 
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( stream, _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
+  void CompactReporter::testRunEnded(TestRunStats const &_testRunStats)
+  {
+    printTotals(stream, _testRunStats.totals);
+    stream << '\n' << std::endl;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+  }
 
-        CompactReporter::~CompactReporter() {}
+  CompactReporter::~CompactReporter() {}
 
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+  CATCH_REGISTER_REPORTER("compact", CompactReporter)
 
 } // end namespace Catch
 // end catch_reporter_compact.cpp
@@ -15297,365 +16558,382 @@ class AssertionPrinter {
 
 #if defined(_MSC_VER)
 #pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
+#pragma warning(disable : 4061) // Not all labels are EXPLICITLY handled in switch
+  // Note that 4062 (not all labels are handled and default is missing) is enabled
 #endif
 
 #if defined(__clang__)
-#  pragma clang diagnostic push
+#pragma clang diagnostic push
 // For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
+#pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
 namespace Catch {
 
-namespace {
+  namespace {
 
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        message(result.getMessage()),
-        messages(_stats.infoMessages),
-        printInfoMessages(_printInfoMessages) {
+    // Formatter impl for ConsoleReporter
+    class ConsoleAssertionPrinter
+    {
+    public:
+      ConsoleAssertionPrinter &operator=(ConsoleAssertionPrinter const &) = delete;
+      ConsoleAssertionPrinter(ConsoleAssertionPrinter const &)            = delete;
+      ConsoleAssertionPrinter(std::ostream &_stream, AssertionStats const &_stats,
+                              bool _printInfoMessages)
+          : stream(_stream), stats(_stats), result(_stats.assertionResult), colour(Colour::None),
+            message(result.getMessage()), messages(_stats.infoMessages),
+            printInfoMessages(_printInfoMessages)
+      {
         switch (result.getResultType()) {
         case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED";
-            //if( result.hasMessage() )
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
+          colour     = Colour::Success;
+          passOrFail = "PASSED";
+          // if( result.hasMessage() )
+          if (_stats.infoMessages.size() == 1)
+            messageLabel = "with message";
+          if (_stats.infoMessages.size() > 1)
+            messageLabel = "with messages";
+          break;
         case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok";
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED";
-            }
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
+          if (result.isOk()) {
+            colour     = Colour::Success;
+            passOrFail = "FAILED - but was ok";
+          }
+          else {
+            colour     = Colour::Error;
             passOrFail = "FAILED";
-            messageLabel = "due to unexpected exception with ";
-            if (_stats.infoMessages.size() == 1)
-                messageLabel += "message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel += "messages";
-            break;
+          }
+          if (_stats.infoMessages.size() == 1)
+            messageLabel = "with message";
+          if (_stats.infoMessages.size() > 1)
+            messageLabel = "with messages";
+          break;
+        case ResultWas::ThrewException:
+          colour       = Colour::Error;
+          passOrFail   = "FAILED";
+          messageLabel = "due to unexpected exception with ";
+          if (_stats.infoMessages.size() == 1)
+            messageLabel += "message";
+          if (_stats.infoMessages.size() > 1)
+            messageLabel += "messages";
+          break;
         case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to a fatal error condition";
-            break;
+          colour       = Colour::Error;
+          passOrFail   = "FAILED";
+          messageLabel = "due to a fatal error condition";
+          break;
         case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "because no exception was thrown where one was expected";
-            break;
-        case ResultWas::Info:
-            messageLabel = "info";
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning";
-            break;
+          colour       = Colour::Error;
+          passOrFail   = "FAILED";
+          messageLabel = "because no exception was thrown where one was expected";
+          break;
+        case ResultWas::Info: messageLabel = "info"; break;
+        case ResultWas::Warning: messageLabel = "warning"; break;
         case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED";
-            colour = Colour::Error;
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "explicitly with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "explicitly with messages";
-            break;
-            // These cases are here to prevent compiler warnings
+          passOrFail = "FAILED";
+          colour     = Colour::Error;
+          if (_stats.infoMessages.size() == 1)
+            messageLabel = "explicitly with message";
+          if (_stats.infoMessages.size() > 1)
+            messageLabel = "explicitly with messages";
+          break;
+          // These cases are here to prevent compiler warnings
         case ResultWas::Unknown:
         case ResultWas::FailureBit:
         case ResultWas::Exception:
-            passOrFail = "** internal error **";
-            colour = Colour::Error;
-            break;
+          passOrFail = "** internal error **";
+          colour     = Colour::Error;
+          break;
         }
-    }
+      }
 
-    void print() const {
+      void print() const
+      {
         printSourceInfo();
         if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
+          printResultType();
+          printOriginalExpression();
+          printReconstructedExpression();
+        }
+        else {
+          stream << '\n';
         }
         printMessage();
-    }
+      }
 
-private:
-    void printResultType() const {
+    private:
+      void printResultType() const
+      {
         if (!passOrFail.empty()) {
-            Colour colourGuard(colour);
-            stream << passOrFail << ":\n";
+          Colour colourGuard(colour);
+          stream << passOrFail << ":\n";
         }
-    }
-    void printOriginalExpression() const {
+      }
+      void printOriginalExpression() const
+      {
         if (result.hasExpression()) {
-            Colour colourGuard(Colour::OriginalExpression);
-            stream << "  ";
-            stream << result.getExpressionInMacro();
-            stream << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
+          Colour colourGuard(Colour::OriginalExpression);
+          stream << "  ";
+          stream << result.getExpressionInMacro();
+          stream << '\n';
+        }
+      }
+      void printReconstructedExpression() const
+      {
         if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            Colour colourGuard(Colour::ReconstructedExpression);
-            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+          stream << "with expansion:\n";
+          Colour colourGuard(Colour::ReconstructedExpression);
+          stream << Column(result.getExpandedExpression()).indent(2) << '\n';
         }
-    }
-    void printMessage() const {
+      }
+      void printMessage() const
+      {
         if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
+          stream << messageLabel << ':' << '\n';
+        for (auto const &msg : messages) {
+          // If this assertion is a warning ignore any INFO messages
+          if (printInfoMessages || msg.type != ResultWas::Info)
+            stream << Column(msg.message).indent(2) << '\n';
+        }
+      }
+      void printSourceInfo() const
+      {
         Colour colourGuard(Colour::FileName);
         stream << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    std::string passOrFail;
-    std::string messageLabel;
-    std::string message;
-    std::vector<MessageInfo> messages;
-    bool printInfoMessages;
-};
+      }
+
+      std::ostream &           stream;
+      AssertionStats const &   stats;
+      AssertionResult const &  result;
+      Colour::Code             colour;
+      std::string              passOrFail;
+      std::string              messageLabel;
+      std::string              message;
+      std::vector<MessageInfo> messages;
+      bool                     printInfoMessages;
+    };
 
-std::size_t makeRatio(std::size_t number, std::size_t total) {
-    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : ratio;
-}
+    std::size_t makeRatio(std::size_t number, std::size_t total)
+    {
+      std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+      return (ratio == 0 && number > 0) ? 1 : ratio;
+    }
 
-std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
-    if (i > j && i > k)
+    std::size_t &findMax(std::size_t &i, std::size_t &j, std::size_t &k)
+    {
+      if (i > j && i > k)
         return i;
-    else if (j > k)
+      else if (j > k)
         return j;
-    else
+      else
         return k;
-}
+    }
 
-struct ColumnInfo {
-    enum Justification { Left, Right };
-    std::string name;
-    int width;
-    Justification justification;
-};
-struct ColumnBreak {};
-struct RowBreak {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
+    struct ColumnInfo
+    {
+      enum Justification { Left, Right };
+      std::string   name;
+      int           width;
+      Justification justification;
+    };
+    struct ColumnBreak
+    {
+    };
+    struct RowBreak
+    {
     };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
 
-    uint64_t m_inNanoseconds;
-    Unit m_units;
+    class Duration
+    {
+      enum class Unit { Auto, Nanoseconds, Microseconds, Milliseconds, Seconds, Minutes };
+      static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+      static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+      static const uint64_t s_nanosecondsInASecond      = 1000 * s_nanosecondsInAMillisecond;
+      static const uint64_t s_nanosecondsInAMinute      = 60 * s_nanosecondsInASecond;
 
-public:
-	explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : Duration(static_cast<uint64_t>(inNanoseconds), units) {
-    }
+      uint64_t m_inNanoseconds;
+      Unit     m_units;
 
-    explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
+    public:
+      explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+          : Duration(static_cast<uint64_t>(inNanoseconds), units)
+      {
+      }
+
+      explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
+          : m_inNanoseconds(inNanoseconds), m_units(units)
+      {
         if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
+          if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+            m_units = Unit::Nanoseconds;
+          else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+            m_units = Unit::Microseconds;
+          else if (m_inNanoseconds < s_nanosecondsInASecond)
+            m_units = Unit::Milliseconds;
+          else if (m_inNanoseconds < s_nanosecondsInAMinute)
+            m_units = Unit::Seconds;
+          else
+            m_units = Unit::Minutes;
+        }
+      }
+
+      auto value() const -> double
+      {
         switch (m_units) {
         case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+          return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
         case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return static_cast<double>(m_inNanoseconds);
-        }
-    }
-    auto unitsAsString() const -> std::string {
+          return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds: return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes: return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default: return static_cast<double>(m_inNanoseconds);
+        }
+      }
+      auto unitsAsString() const -> std::string
+      {
         switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns";
-        case Unit::Microseconds:
-            return "us";
-        case Unit::Milliseconds:
-            return "ms";
-        case Unit::Seconds:
-            return "s";
-        case Unit::Minutes:
-            return "m";
-        default:
-            return "** internal error **";
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << " " << duration.unitsAsString();
-    }
-};
-} // end anon namespace
+        case Unit::Nanoseconds: return "ns";
+        case Unit::Microseconds: return "us";
+        case Unit::Milliseconds: return "ms";
+        case Unit::Seconds: return "s";
+        case Unit::Minutes: return "m";
+        default: return "** internal error **";
+        }
+      }
+      friend auto operator<<(std::ostream &os, Duration const &duration) -> std::ostream &
+      {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+      }
+    };
+  } // namespace
 
-class TablePrinter {
-    std::ostream& m_os;
+  class TablePrinter
+  {
+    std::ostream &          m_os;
     std::vector<ColumnInfo> m_columnInfos;
-    std::ostringstream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( std::move( columnInfos ) ) {}
+    std::ostringstream      m_oss;
+    int                     m_currentColumn = -1;
+    bool                    m_isOpen        = false;
 
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
+  public:
+    TablePrinter(std::ostream &os, std::vector<ColumnInfo> columnInfos)
+        : m_os(os), m_columnInfos(std::move(columnInfos))
+    {
     }
 
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
+    auto columnInfos() const -> std::vector<ColumnInfo> const & { return m_columnInfos; }
 
-			Columns headerCols;
-			Spacer spacer(2);
-			for (auto const& info : m_columnInfos) {
-				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
-				headerCols += spacer;
-			}
-			m_os << headerCols << "\n";
+    void open()
+    {
+      if (!m_isOpen) {
+        m_isOpen = true;
+        *this << RowBreak();
 
-            m_os << Catch::getLineOfChars<'-'>() << "\n";
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << std::endl;
-            m_isOpen = false;
+        Columns headerCols;
+        Spacer  spacer(2);
+        for (auto const &info : m_columnInfos) {
+          headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+          headerCols += spacer;
         }
-    }
+        m_os << headerCols << '\n';
 
-    template<typename T>
-    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
+        m_os << Catch::getLineOfChars<'-'>() << '\n';
+      }
     }
-
-    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        // This takes account of utf8 encodings
-        auto strSize = Catch::StringRef(colStr).numberOfCharacters();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << "\n";
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 2 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 2), ' ')
-            : std::string();
-        if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << " ";
-        else
-            tp.m_os << padding << colStr << " ";
-        return tp;
+    void close()
+    {
+      if (m_isOpen) {
+        *this << RowBreak();
+        m_os << std::endl;
+        m_isOpen = false;
+      }
     }
 
-    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << "\n";
-            tp.m_currentColumn = -1;
-        }
-        return tp;
+    template <typename T> friend TablePrinter &operator<<(TablePrinter &tp, T const &value)
+    {
+      tp.m_oss << value;
+      return tp;
     }
-};
 
-ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
-    : StreamingReporterBase(config),
-    m_tablePrinter(new TablePrinter(config.stream(),
+    friend TablePrinter &operator<<(TablePrinter &tp, ColumnBreak)
+    {
+      auto       colStr  = tp.m_oss.str();
+      const auto strSize = colStr.size();
+      tp.m_oss.str("");
+      tp.open();
+      if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+        tp.m_currentColumn = -1;
+        tp.m_os << '\n';
+      }
+      tp.m_currentColumn++;
+
+      auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+      auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+                         ? std::string(colInfo.width - (strSize + 1), ' ')
+                         : std::string();
+      if (colInfo.justification == ColumnInfo::Left)
+        tp.m_os << colStr << padding << ' ';
+      else
+        tp.m_os << padding << colStr << ' ';
+      return tp;
+    }
+
+    friend TablePrinter &operator<<(TablePrinter &tp, RowBreak)
     {
-        { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-        { "samples      mean       std dev", 14, ColumnInfo::Right },
-        { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
-        { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
-    })) {}
-ConsoleReporter::~ConsoleReporter() = default;
+      if (tp.m_currentColumn > 0) {
+        tp.m_os << '\n';
+        tp.m_currentColumn = -1;
+      }
+      return tp;
+    }
+  };
+
+  ConsoleReporter::ConsoleReporter(ReporterConfig const &config)
+      : StreamingReporterBase(config),
+        m_tablePrinter(new TablePrinter(config.stream(), [&config]() -> std::vector<ColumnInfo> {
+          if (config.fullConfig()->benchmarkNoAnalysis()) {
+            return {{"benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left},
+                    {"     samples", 14, ColumnInfo::Right},
+                    {"  iterations", 14, ColumnInfo::Right},
+                    {"        mean", 14, ColumnInfo::Right}};
+          }
+          else {
+            return {{"benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left},
+                    {"samples      mean       std dev", 14, ColumnInfo::Right},
+                    {"iterations   low mean   low std dev", 14, ColumnInfo::Right},
+                    {"estimated    high mean  high std dev", 14, ColumnInfo::Right}};
+          }
+        }()))
+  {
+  }
+  ConsoleReporter::~ConsoleReporter() = default;
 
-std::string ConsoleReporter::getDescription() {
+  std::string ConsoleReporter::getDescription()
+  {
     return "Reports test results as plain lines of text";
-}
+  }
 
-void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+  void ConsoleReporter::noMatchingTestCases(std::string const &spec)
+  {
     stream << "No test cases matched '" << spec << '\'' << std::endl;
-}
+  }
+
+  void ConsoleReporter::reportInvalidArguments(std::string const &arg)
+  {
+    stream << "Invalid Filter: " << arg << std::endl;
+  }
 
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+  void ConsoleReporter::assertionStarting(AssertionInfo const &) {}
 
-bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
+  bool ConsoleReporter::assertionEnded(AssertionStats const &_assertionStats)
+  {
+    AssertionResult const &result = _assertionStats.assertionResult;
 
     bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
 
     // Drop out if result was successful but we're not printing them.
     if (!includeResults && result.getResultType() != ResultWas::Warning)
-        return false;
+      return false;
 
     lazyPrint();
 
@@ -15663,284 +16941,313 @@ bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
     printer.print();
     stream << std::endl;
     return true;
-}
+  }
 
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+  void ConsoleReporter::sectionStarting(SectionInfo const &_sectionInfo)
+  {
     m_tablePrinter->close();
     m_headerPrinted = false;
     StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+  }
+  void ConsoleReporter::sectionEnded(SectionStats const &_sectionStats)
+  {
     m_tablePrinter->close();
     if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        Colour colour(Colour::ResultError);
-        if (m_sectionStack.size() > 1)
-            stream << "\nNo assertions in section";
-        else
-            stream << "\nNo assertions in test case";
-        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+      lazyPrint();
+      Colour colour(Colour::ResultError);
+      if (m_sectionStack.size() > 1)
+        stream << "\nNo assertions in section";
+      else
+        stream << "\nNo assertions in test case";
+      stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
     }
     if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+      stream << getFormattedDuration(_sectionStats.durationInSeconds)
+             << " s: " << _sectionStats.sectionInfo.name << std::endl;
     }
     if (m_headerPrinted) {
-        m_headerPrinted = false;
+      m_headerPrinted = false;
     }
     StreamingReporterBase::sectionEnded(_sectionStats);
-}
+  }
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-void ConsoleReporter::benchmarkPreparing(std::string const& name) {
-	lazyPrintWithoutClosingBenchmarkTable();
+  void ConsoleReporter::benchmarkPreparing(std::string const &name)
+  {
+    lazyPrintWithoutClosingBenchmarkTable();
 
-	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
+    auto nameCol =
+        Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
 
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
+    bool firstLine = true;
+    for (auto line : nameCol) {
+      if (!firstLine)
+        (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+      else
+        firstLine = false;
 
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
+      (*m_tablePrinter) << line << ColumnBreak();
+    }
+  }
 
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-	(*m_tablePrinter) << info.samples << ColumnBreak()
-		<< info.iterations << ColumnBreak()
-		<< Duration(info.estimatedDuration) << ColumnBreak();
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-	(*m_tablePrinter) << ColumnBreak()
-		<< Duration(stats.mean.point.count()) << ColumnBreak()
-		<< Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-		<< Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-		<< Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-		<< Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-		<< Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-}
+  void ConsoleReporter::benchmarkStarting(BenchmarkInfo const &info)
+  {
+    (*m_tablePrinter) << info.samples << ColumnBreak() << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+      (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+  }
+  void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const &stats)
+  {
+    if (m_config->benchmarkNoAnalysis()) {
+      (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else {
+      (*m_tablePrinter) << ColumnBreak() << Duration(stats.mean.point.count()) << ColumnBreak()
+                        << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+                        << Duration(stats.mean.upper_bound.count()) << ColumnBreak()
+                        << ColumnBreak() << Duration(stats.standardDeviation.point.count())
+                        << ColumnBreak() << Duration(stats.standardDeviation.lower_bound.count())
+                        << ColumnBreak() << Duration(stats.standardDeviation.upper_bound.count())
+                        << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak()
+                        << ColumnBreak();
+    }
+  }
 
-void ConsoleReporter::benchmarkFailed(std::string const& error) {
-	Colour colour(Colour::Red);
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ")"
-        << ColumnBreak() << RowBreak();
-}
+  void ConsoleReporter::benchmarkFailed(std::string const &error)
+  {
+    Colour colour(Colour::Red);
+    (*m_tablePrinter) << "Benchmark failed (" << error << ')' << ColumnBreak() << RowBreak();
+  }
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+  void ConsoleReporter::testCaseEnded(TestCaseStats const &_testCaseStats)
+  {
     m_tablePrinter->close();
     StreamingReporterBase::testCaseEnded(_testCaseStats);
     m_headerPrinted = false;
-}
-void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+  }
+  void ConsoleReporter::testGroupEnded(TestGroupStats const &_testGroupStats)
+  {
     if (currentGroupInfo.used) {
-        printSummaryDivider();
-        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-        printTotals(_testGroupStats.totals);
-        stream << '\n' << std::endl;
+      printSummaryDivider();
+      stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+      printTotals(_testGroupStats.totals);
+      stream << '\n' << std::endl;
     }
     StreamingReporterBase::testGroupEnded(_testGroupStats);
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+  }
+  void ConsoleReporter::testRunEnded(TestRunStats const &_testRunStats)
+  {
     printTotalsDivider(_testRunStats.totals);
     printTotals(_testRunStats.totals);
     stream << std::endl;
     StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+  }
+  void ConsoleReporter::testRunStarting(TestRunInfo const &_testInfo)
+  {
     StreamingReporterBase::testRunStarting(_testInfo);
     printTestFilters();
-}
+  }
 
-void ConsoleReporter::lazyPrint() {
+  void ConsoleReporter::lazyPrint()
+  {
 
     m_tablePrinter->close();
     lazyPrintWithoutClosingBenchmarkTable();
-}
+  }
 
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+  void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable()
+  {
 
     if (!currentTestRunInfo.used)
-        lazyPrintRunInfo();
+      lazyPrintRunInfo();
     if (!currentGroupInfo.used)
-        lazyPrintGroupInfo();
+      lazyPrintGroupInfo();
 
     if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
+      printTestCaseAndSectionHeader();
+      m_headerPrinted = true;
     }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
+  }
+  void ConsoleReporter::lazyPrintRunInfo()
+  {
     stream << '\n' << getLineOfChars<'~'>() << '\n';
     Colour colour(Colour::SecondaryText);
-    stream << currentTestRunInfo->name
-        << " is a Catch v" << libraryVersion() << " host application.\n"
-        << "Run with -? for options\n\n";
+    stream << currentTestRunInfo->name << " is a Catch v" << libraryVersion()
+           << " host application.\n"
+           << "Run with -? for options\n\n";
 
     if (m_config->rngSeed() != 0)
-        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+      stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
 
     currentTestRunInfo.used = true;
-}
-void ConsoleReporter::lazyPrintGroupInfo() {
+  }
+  void ConsoleReporter::lazyPrintGroupInfo()
+  {
     if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
-        printClosedHeader("Group: " + currentGroupInfo->name);
-        currentGroupInfo.used = true;
+      printClosedHeader("Group: " + currentGroupInfo->name);
+      currentGroupInfo.used = true;
     }
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
+  }
+  void ConsoleReporter::printTestCaseAndSectionHeader()
+  {
     assert(!m_sectionStack.empty());
     printOpenHeader(currentTestCaseInfo->name);
 
     if (m_sectionStack.size() > 1) {
-        Colour colourGuard(Colour::Headers);
+      Colour colourGuard(Colour::Headers);
 
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
+      auto it   = m_sectionStack.begin() + 1, // Skip first section (test case)
+          itEnd = m_sectionStack.end();
+      for (; it != itEnd; ++it)
+        printHeaderString(it->name, 2);
     }
 
     SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
 
-    if (!lineInfo.empty()) {
-        stream << getLineOfChars<'-'>() << '\n';
-        Colour colourGuard(Colour::FileName);
-        stream << lineInfo << '\n';
-    }
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
     stream << getLineOfChars<'.'>() << '\n' << std::endl;
-}
+  }
 
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
+  void ConsoleReporter::printClosedHeader(std::string const &_name)
+  {
     printOpenHeader(_name);
     stream << getLineOfChars<'.'>() << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
+  }
+  void ConsoleReporter::printOpenHeader(std::string const &_name)
+  {
     stream << getLineOfChars<'-'>() << '\n';
     {
-        Colour colourGuard(Colour::Headers);
-        printHeaderString(_name);
+      Colour colourGuard(Colour::Headers);
+      printHeaderString(_name);
     }
-}
+  }
 
-// if string has a : in first line will set indent to follow it on
-// subsequent lines
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+  // if string has a : in first line will set indent to follow it on
+  // subsequent lines
+  void ConsoleReporter::printHeaderString(std::string const &_string, std::size_t indent)
+  {
     std::size_t i = _string.find(": ");
     if (i != std::string::npos)
-        i += 2;
+      i += 2;
     else
-        i = 0;
+      i = 0;
     stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
-}
+  }
 
-struct SummaryColumn {
+  struct SummaryColumn
+  {
 
-    SummaryColumn( std::string _label, Colour::Code _colour )
-    :   label( std::move( _label ) ),
-        colour( _colour ) {}
-    SummaryColumn addRow( std::size_t count ) {
-        ReusableStringStream rss;
-        rss << count;
-        std::string row = rss.str();
-        for (auto& oldRow : rows) {
-            while (oldRow.size() < row.size())
-                oldRow = ' ' + oldRow;
-            while (oldRow.size() > row.size())
-                row = ' ' + row;
-        }
-        rows.push_back(row);
-        return *this;
+    SummaryColumn(std::string _label, Colour::Code _colour)
+        : label(std::move(_label)), colour(_colour)
+    {
     }
-
-    std::string label;
-    Colour::Code colour;
+    SummaryColumn addRow(std::size_t count)
+    {
+      ReusableStringStream rss;
+      rss << count;
+      std::string row = rss.str();
+      for (auto &oldRow : rows) {
+        while (oldRow.size() < row.size())
+          oldRow = ' ' + oldRow;
+        while (oldRow.size() > row.size())
+          row = ' ' + row;
+      }
+      rows.push_back(row);
+      return *this;
+    }
+
+    std::string              label;
+    Colour::Code             colour;
     std::vector<std::string> rows;
+  };
 
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
+  void ConsoleReporter::printTotals(Totals const &totals)
+  {
     if (totals.testCases.total() == 0) {
-        stream << Colour(Colour::Warning) << "No tests ran\n";
-    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
-        stream << Colour(Colour::ResultSuccess) << "All tests passed";
-        stream << " ("
-            << pluralise(totals.assertions.passed, "assertion") << " in "
-            << pluralise(totals.testCases.passed, "test case") << ')'
-            << '\n';
-    } else {
-
-        std::vector<SummaryColumn> columns;
-        columns.push_back(SummaryColumn("", Colour::None)
-                          .addRow(totals.testCases.total())
-                          .addRow(totals.assertions.total()));
-        columns.push_back(SummaryColumn("passed", Colour::Success)
-                          .addRow(totals.testCases.passed)
-                          .addRow(totals.assertions.passed));
-        columns.push_back(SummaryColumn("failed", Colour::ResultError)
-                          .addRow(totals.testCases.failed)
-                          .addRow(totals.assertions.failed));
-        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
-                          .addRow(totals.testCases.failedButOk)
-                          .addRow(totals.assertions.failedButOk));
-
-        printSummaryRow("test cases", columns, 0);
-        printSummaryRow("assertions", columns, 1);
+      stream << Colour(Colour::Warning) << "No tests ran\n";
+    }
+    else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+      stream << Colour(Colour::ResultSuccess) << "All tests passed";
+      stream << " (" << pluralise(totals.assertions.passed, "assertion") << " in "
+             << pluralise(totals.testCases.passed, "test case") << ')' << '\n';
+    }
+    else {
+
+      std::vector<SummaryColumn> columns;
+      columns.push_back(SummaryColumn("", Colour::None)
+                            .addRow(totals.testCases.total())
+                            .addRow(totals.assertions.total()));
+      columns.push_back(SummaryColumn("passed", Colour::Success)
+                            .addRow(totals.testCases.passed)
+                            .addRow(totals.assertions.passed));
+      columns.push_back(SummaryColumn("failed", Colour::ResultError)
+                            .addRow(totals.testCases.failed)
+                            .addRow(totals.assertions.failed));
+      columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+                            .addRow(totals.testCases.failedButOk)
+                            .addRow(totals.assertions.failedButOk));
+
+      printSummaryRow("test cases", columns, 0);
+      printSummaryRow("assertions", columns, 1);
     }
-}
-void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+  }
+  void ConsoleReporter::printSummaryRow(std::string const &               label,
+                                        std::vector<SummaryColumn> const &cols, std::size_t row)
+  {
     for (auto col : cols) {
-        std::string value = col.rows[row];
-        if (col.label.empty()) {
-            stream << label << ": ";
-            if (value != "0")
-                stream << value;
-            else
-                stream << Colour(Colour::Warning) << "- none -";
-        } else if (value != "0") {
-            stream << Colour(Colour::LightGrey) << " | ";
-            stream << Colour(col.colour)
-                << value << ' ' << col.label;
-        }
+      std::string value = col.rows[row];
+      if (col.label.empty()) {
+        stream << label << ": ";
+        if (value != "0")
+          stream << value;
+        else
+          stream << Colour(Colour::Warning) << "- none -";
+      }
+      else if (value != "0") {
+        stream << Colour(Colour::LightGrey) << " | ";
+        stream << Colour(col.colour) << value << ' ' << col.label;
+      }
     }
     stream << '\n';
-}
+  }
 
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+  void ConsoleReporter::printTotalsDivider(Totals const &totals)
+  {
     if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)--;
-
-        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
-        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
-        if (totals.testCases.allPassed())
-            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
-        else
-            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
-    } else {
-        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+      std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+      std::size_t failedButOkRatio =
+          makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+      std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+      while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+        findMax(failedRatio, failedButOkRatio, passedRatio)++;
+      while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+        findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+      stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+      stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+      if (totals.testCases.allPassed())
+        stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+      else
+        stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+    }
+    else {
+      stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
     }
     stream << '\n';
-}
-void ConsoleReporter::printSummaryDivider() {
-    stream << getLineOfChars<'-'>() << '\n';
-}
+  }
+  void ConsoleReporter::printSummaryDivider() { stream << getLineOfChars<'-'>() << '\n'; }
 
-void ConsoleReporter::printTestFilters() {
+  void ConsoleReporter::printTestFilters()
+  {
     if (m_config->testSpec().hasFilters())
-        stream << Colour(Colour::BrightYellow) << "Filters: " << serializeFilters( m_config->getTestsOrTags() ) << '\n';
-}
+      stream << Colour(Colour::BrightYellow)
+             << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+  }
 
-CATCH_REGISTER_REPORTER("console", ConsoleReporter)
+  CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 
 } // end namespace Catch
 
@@ -15949,258 +17256,256 @@ CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 #endif
 
 #if defined(__clang__)
-#  pragma clang diagnostic pop
+#pragma clang diagnostic pop
 #endif
 // end catch_reporter_console.cpp
 // start catch_reporter_junit.cpp
 
+#include <algorithm>
 #include <cassert>
-#include <sstream>
 #include <ctime>
-#include <algorithm>
+#include <sstream>
 
 namespace Catch {
 
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+  namespace {
+    std::string getCurrentTimestamp()
+    {
+      // Beware, this is not reentrant because of backward compatibility issues
+      // Also, UTC only, again because of backward compatibility (%z is C++11)
+      time_t rawtime;
+      std::time(&rawtime);
+      auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
 
 #ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
+      std::tm timeInfo = {};
+      gmtime_s(&timeInfo, &rawtime);
 #else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
+      std::tm *timeInfo;
+      timeInfo = std::gmtime(&rawtime);
 #endif
 
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+      char              timeStamp[timeStampSize];
+      const char *const fmt = "%Y-%m-%dT%H:%M:%SZ";
 
 #ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+      std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
 #else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+      std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
 #endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-    JunitReporter::~JunitReporter() {}
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
+      return std::string(timeStamp);
     }
 
-    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-    }
+    std::string fileNameTag(const std::vector<std::string> &tags)
+    {
+      auto it = std::find_if(begin(tags), end(tags),
+                             [](std::string const &tag) { return tag.front() == '#'; });
+      if (it != tags.end())
+        return it->substr(1);
+      return std::string();
+    }
+  } // anonymous namespace
+
+  JunitReporter::JunitReporter(ReporterConfig const &_config)
+      : CumulativeReporterBase(_config), xml(_config.stream())
+  {
+    m_reporterPrefs.shouldRedirectStdOut      = true;
+    m_reporterPrefs.shouldReportAllAssertions = true;
+  }
 
-    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-        CumulativeReporterBase::testGroupStarting( groupInfo );
-    }
+  JunitReporter::~JunitReporter() {}
 
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
+  std::string JunitReporter::getDescription()
+  {
+    return "Reports test results in an XML format that looks like Ant's junitreport target";
+  }
 
-    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        return CumulativeReporterBase::assertionEnded( assertionStats );
-    }
+  void JunitReporter::noMatchingTestCases(std::string const & /*spec*/) {}
 
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
+  void JunitReporter::testRunStarting(TestRunInfo const &runInfo)
+  {
+    CumulativeReporterBase::testRunStarting(runInfo);
+    xml.startElement("testsuites");
+  }
 
-    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        double suiteTime = suiteTimer.getElapsedSeconds();
-        CumulativeReporterBase::testGroupEnded( testGroupStats );
-        writeGroup( *m_testGroups.back(), suiteTime );
-    }
+  void JunitReporter::testGroupStarting(GroupInfo const &groupInfo)
+  {
+    suiteTimer.start();
+    stdOutForSuite.clear();
+    stdErrForSuite.clear();
+    unexpectedExceptions = 0;
+    CumulativeReporterBase::testGroupStarting(groupInfo);
+  }
 
-    void JunitReporter::testRunEndedCumulative() {
-        xml.endElement();
-    }
+  void JunitReporter::testCaseStarting(TestCaseInfo const &testCaseInfo)
+  {
+    m_okToFail = testCaseInfo.okToFail();
+  }
 
-    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+  bool JunitReporter::assertionEnded(AssertionStats const &assertionStats)
+  {
+    if (assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail)
+      unexpectedExceptions++;
+    return CumulativeReporterBase::assertionEnded(assertionStats);
+  }
 
-        TestGroupStats const& stats = groupNode.value;
-        xml.writeAttribute( "name", stats.groupInfo.name );
-        xml.writeAttribute( "errors", unexpectedExceptions );
-        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "tests", stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname", "tbd" ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time", "" );
-        else
-            xml.writeAttribute( "time", suiteTime );
-        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-        // Write properties if there are any
-        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
-            auto properties = xml.scopedElement("properties");
-            if (m_config->hasTestFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "filters")
-                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
-            }
-            if (m_config->rngSeed() != 0) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "random-seed")
-                    .writeAttribute("value", m_config->rngSeed());
-            }
-        }
+  void JunitReporter::testCaseEnded(TestCaseStats const &testCaseStats)
+  {
+    stdOutForSuite += testCaseStats.stdOut;
+    stdErrForSuite += testCaseStats.stdErr;
+    CumulativeReporterBase::testCaseEnded(testCaseStats);
+  }
 
-        // Write test cases
-        for( auto const& child : groupNode.children )
-            writeTestCase( *child );
+  void JunitReporter::testGroupEnded(TestGroupStats const &testGroupStats)
+  {
+    double suiteTime = suiteTimer.getElapsedSeconds();
+    CumulativeReporterBase::testGroupEnded(testGroupStats);
+    writeGroup(*m_testGroups.back(), suiteTime);
+  }
 
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), false );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), false );
-    }
+  void JunitReporter::testRunEndedCumulative() { xml.endElement(); }
 
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
+  void JunitReporter::writeGroup(TestGroupNode const &groupNode, double suiteTime)
+  {
+    XmlWriter::ScopedElement e = xml.scopedElement("testsuite");
 
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
+    TestGroupStats const &stats = groupNode.value;
+    xml.writeAttribute("name", stats.groupInfo.name);
+    xml.writeAttribute("errors", unexpectedExceptions);
+    xml.writeAttribute("failures", stats.totals.assertions.failed - unexpectedExceptions);
+    xml.writeAttribute("tests", stats.totals.assertions.total());
+    xml.writeAttribute("hostname", "tbd"); // !TBD
+    if (m_config->showDurations() == ShowDurations::Never)
+      xml.writeAttribute("time", "");
+    else
+      xml.writeAttribute("time", suiteTime);
+    xml.writeAttribute("timestamp", getCurrentTimestamp());
+
+    // Write properties if there are any
+    if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+      auto properties = xml.scopedElement("properties");
+      if (m_config->hasTestFilters()) {
+        xml.scopedElement("property")
+            .writeAttribute("name", "filters")
+            .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+      }
+      if (m_config->rngSeed() != 0) {
+        xml.scopedElement("property")
+            .writeAttribute("name", "random-seed")
+            .writeAttribute("value", m_config->rngSeed());
+      }
+    }
+
+    // Write test cases
+    for (auto const &child : groupNode.children)
+      writeTestCase(*child);
+
+    xml.scopedElement("system-out").writeText(trim(stdOutForSuite), false);
+    xml.scopedElement("system-err").writeText(trim(stdErrForSuite), false);
+  }
 
-        std::string className = stats.testInfo.className;
+  void JunitReporter::writeTestCase(TestCaseNode const &testCaseNode)
+  {
+    TestCaseStats const &stats = testCaseNode.value;
 
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo.tags);
-            if ( className.empty() )
-                className = "global";
-        }
+    // All test cases have exactly one section - which represents the
+    // test case itself. That section may have 0-n nested sections
+    assert(testCaseNode.children.size() == 1);
+    SectionNode const &rootSection = *testCaseNode.children.front();
 
-        if ( !m_config->name().empty() )
-            className = m_config->name() + "." + className;
+    std::string className = stats.testInfo.className;
 
-        writeSection( className, "", rootSection );
+    if (className.empty()) {
+      className = fileNameTag(stats.testInfo.tags);
+      if (className.empty())
+        className = "global";
     }
 
-    void JunitReporter::writeSection(  std::string const& className,
-                        std::string const& rootName,
-                        SectionNode const& sectionNode ) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if( !sectionNode.assertions.empty() ||
-            !sectionNode.stdOut.empty() ||
-            !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname", name );
-                xml.writeAttribute( "name", "root" );
-            }
-            else {
-                xml.writeAttribute( "classname", className );
-                xml.writeAttribute( "name", name );
-            }
-            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-            writeAssertions( sectionNode );
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode );
-            else
-                writeSection( className, name, *childNode );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for( auto const& assertion : sectionNode.assertions )
-            writeAssertion( assertion );
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if( !result.isOk() ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                    elementName = "failure";
-                    break;
-                case ResultWas::ExpressionFailed:
-                    elementName = "failure";
-                    break;
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
+    if (!m_config->name().empty())
+      className = m_config->name() + "." + className;
 
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+    writeSection(className, "", rootSection);
+  }
 
-            xml.writeAttribute( "message", result.getExpandedExpression() );
-            xml.writeAttribute( "type", result.getTestMacroName() );
+  void JunitReporter::writeSection(std::string const &className, std::string const &rootName,
+                                   SectionNode const &sectionNode)
+  {
+    std::string name = trim(sectionNode.stats.sectionInfo.name);
+    if (!rootName.empty())
+      name = rootName + '/' + name;
+
+    if (!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() ||
+        !sectionNode.stdErr.empty()) {
+      XmlWriter::ScopedElement e = xml.scopedElement("testcase");
+      if (className.empty()) {
+        xml.writeAttribute("classname", name);
+        xml.writeAttribute("name", "root");
+      }
+      else {
+        xml.writeAttribute("classname", className);
+        xml.writeAttribute("name", name);
+      }
+      xml.writeAttribute("time", ::Catch::Detail::stringify(sectionNode.stats.durationInSeconds));
+
+      writeAssertions(sectionNode);
+
+      if (!sectionNode.stdOut.empty())
+        xml.scopedElement("system-out").writeText(trim(sectionNode.stdOut), false);
+      if (!sectionNode.stdErr.empty())
+        xml.scopedElement("system-err").writeText(trim(sectionNode.stdErr), false);
+    }
+    for (auto const &childNode : sectionNode.childSections)
+      if (className.empty())
+        writeSection(name, "", *childNode);
+      else
+        writeSection(className, name, *childNode);
+  }
 
-            ReusableStringStream rss;
-            if( !result.getMessage().empty() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
+  void JunitReporter::writeAssertions(SectionNode const &sectionNode)
+  {
+    for (auto const &assertion : sectionNode.assertions)
+      writeAssertion(assertion);
+  }
 
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), false );
-        }
+  void JunitReporter::writeAssertion(AssertionStats const &stats)
+  {
+    AssertionResult const &result = stats.assertionResult;
+    if (!result.isOk()) {
+      std::string elementName;
+      switch (result.getResultType()) {
+      case ResultWas::ThrewException:
+      case ResultWas::FatalErrorCondition: elementName = "error"; break;
+      case ResultWas::ExplicitFailure: elementName = "failure"; break;
+      case ResultWas::ExpressionFailed: elementName = "failure"; break;
+      case ResultWas::DidntThrowException: elementName = "failure"; break;
+
+      // We should never see these here:
+      case ResultWas::Info:
+      case ResultWas::Warning:
+      case ResultWas::Ok:
+      case ResultWas::Unknown:
+      case ResultWas::FailureBit:
+      case ResultWas::Exception: elementName = "internalError"; break;
+      }
+
+      XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+      xml.writeAttribute("message", result.getExpandedExpression());
+      xml.writeAttribute("type", result.getTestMacroName());
+
+      ReusableStringStream rss;
+      if (!result.getMessage().empty())
+        rss << result.getMessage() << '\n';
+      for (auto const &msg : stats.infoMessages)
+        if (msg.type == ResultWas::Info)
+          rss << msg.message << '\n';
+
+      rss << "at " << result.getSourceInfo();
+      xml.writeText(rss.str(), false);
     }
+  }
 
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+  CATCH_REGISTER_REPORTER("junit", JunitReporter)
 
 } // end namespace Catch
 // end catch_reporter_junit.cpp
@@ -16210,145 +17515,166 @@ namespace Catch {
 
 namespace Catch {
 
-    ListeningReporter::ListeningReporter() {
-        // We will assume that listeners will always want all assertions
-        m_preferences.shouldReportAllAssertions = true;
-    }
+  ListeningReporter::ListeningReporter()
+  {
+    // We will assume that listeners will always want all assertions
+    m_preferences.shouldReportAllAssertions = true;
+  }
 
-    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( std::move( listener ) );
-    }
+  void ListeningReporter::addListener(IStreamingReporterPtr &&listener)
+  {
+    m_listeners.push_back(std::move(listener));
+  }
 
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = std::move( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
-    }
+  void ListeningReporter::addReporter(IStreamingReporterPtr &&reporter)
+  {
+    assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+    m_reporter                         = std::move(reporter);
+    m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+  }
 
-    ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_preferences;
-    }
+  ReporterPreferences ListeningReporter::getPreferences() const { return m_preferences; }
+
+  std::set<Verbosity> ListeningReporter::getSupportedVerbosities() { return std::set<Verbosity>{}; }
 
-    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
+  void ListeningReporter::noMatchingTestCases(std::string const &spec)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->noMatchingTestCases(spec);
     }
+    m_reporter->noMatchingTestCases(spec);
+  }
 
-    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->noMatchingTestCases( spec );
-        }
-        m_reporter->noMatchingTestCases( spec );
+  void ListeningReporter::reportInvalidArguments(std::string const &arg)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->reportInvalidArguments(arg);
     }
+    m_reporter->reportInvalidArguments(arg);
+  }
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkPreparing(name);
-		}
-		m_reporter->benchmarkPreparing(name);
-	}
-    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
-        }
-        m_reporter->benchmarkStarting( benchmarkInfo );
+  void ListeningReporter::benchmarkPreparing(std::string const &name)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->benchmarkPreparing(name);
     }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
-        }
-        m_reporter->benchmarkEnded( benchmarkStats );
+    m_reporter->benchmarkPreparing(name);
+  }
+  void ListeningReporter::benchmarkStarting(BenchmarkInfo const &benchmarkInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->benchmarkStarting(benchmarkInfo);
+    }
+    m_reporter->benchmarkStarting(benchmarkInfo);
+  }
+  void ListeningReporter::benchmarkEnded(BenchmarkStats<> const &benchmarkStats)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->benchmarkEnded(benchmarkStats);
     }
+    m_reporter->benchmarkEnded(benchmarkStats);
+  }
 
-	void ListeningReporter::benchmarkFailed( std::string const& error ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkFailed(error);
-		}
-		m_reporter->benchmarkFailed(error);
-	}
+  void ListeningReporter::benchmarkFailed(std::string const &error)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->benchmarkFailed(error);
+    }
+    m_reporter->benchmarkFailed(error);
+  }
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
-        }
-        m_reporter->testRunStarting( testRunInfo );
+  void ListeningReporter::testRunStarting(TestRunInfo const &testRunInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->testRunStarting(testRunInfo);
     }
+    m_reporter->testRunStarting(testRunInfo);
+  }
 
-    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupStarting( groupInfo );
-        }
-        m_reporter->testGroupStarting( groupInfo );
+  void ListeningReporter::testGroupStarting(GroupInfo const &groupInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->testGroupStarting(groupInfo);
     }
+    m_reporter->testGroupStarting(groupInfo);
+  }
 
-    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
-        }
-        m_reporter->testCaseStarting( testInfo );
+  void ListeningReporter::testCaseStarting(TestCaseInfo const &testInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->testCaseStarting(testInfo);
     }
+    m_reporter->testCaseStarting(testInfo);
+  }
 
-    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
-        }
-        m_reporter->sectionStarting( sectionInfo );
+  void ListeningReporter::sectionStarting(SectionInfo const &sectionInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->sectionStarting(sectionInfo);
     }
+    m_reporter->sectionStarting(sectionInfo);
+  }
 
-    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
-        }
-        m_reporter->assertionStarting( assertionInfo );
+  void ListeningReporter::assertionStarting(AssertionInfo const &assertionInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->assertionStarting(assertionInfo);
     }
+    m_reporter->assertionStarting(assertionInfo);
+  }
 
-    // The return value indicates if the messages buffer should be cleared:
-    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto const& listener : m_listeners ) {
-            static_cast<void>( listener->assertionEnded( assertionStats ) );
-        }
-        return m_reporter->assertionEnded( assertionStats );
+  // The return value indicates if the messages buffer should be cleared:
+  bool ListeningReporter::assertionEnded(AssertionStats const &assertionStats)
+  {
+    for (auto const &listener : m_listeners) {
+      static_cast<void>(listener->assertionEnded(assertionStats));
     }
+    return m_reporter->assertionEnded(assertionStats);
+  }
 
-    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
-        }
-        m_reporter->sectionEnded( sectionStats );
+  void ListeningReporter::sectionEnded(SectionStats const &sectionStats)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->sectionEnded(sectionStats);
     }
+    m_reporter->sectionEnded(sectionStats);
+  }
 
-    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
-        }
-        m_reporter->testCaseEnded( testCaseStats );
+  void ListeningReporter::testCaseEnded(TestCaseStats const &testCaseStats)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->testCaseEnded(testCaseStats);
     }
+    m_reporter->testCaseEnded(testCaseStats);
+  }
 
-    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupEnded( testGroupStats );
-        }
-        m_reporter->testGroupEnded( testGroupStats );
+  void ListeningReporter::testGroupEnded(TestGroupStats const &testGroupStats)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->testGroupEnded(testGroupStats);
     }
+    m_reporter->testGroupEnded(testGroupStats);
+  }
 
-    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
-        }
-        m_reporter->testRunEnded( testRunStats );
+  void ListeningReporter::testRunEnded(TestRunStats const &testRunStats)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->testRunEnded(testRunStats);
     }
+    m_reporter->testRunEnded(testRunStats);
+  }
 
-    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->skipTest( testInfo );
-        }
-        m_reporter->skipTest( testInfo );
+  void ListeningReporter::skipTest(TestCaseInfo const &testInfo)
+  {
+    for (auto const &listener : m_listeners) {
+      listener->skipTest(testInfo);
     }
+    m_reporter->skipTest(testInfo);
+  }
 
-    bool ListeningReporter::isMulti() const {
-        return true;
-    }
+  bool ListeningReporter::isMulti() const { return true; }
 
 } // end namespace Catch
 // end catch_reporter_listening.cpp
@@ -16356,257 +17682,255 @@ namespace Catch {
 
 #if defined(_MSC_VER)
 #pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
+#pragma warning(disable : 4061) // Not all labels are EXPLICITLY handled in switch
+                                // Note that 4062 (not all labels are handled
+                                // and default is missing) is enabled
 #endif
 
 namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig const& _config )
-    :   StreamingReporterBase( _config ),
-        m_xml(_config.stream())
-    {
-        m_reporterPrefs.shouldRedirectStdOut = true;
-        m_reporterPrefs.shouldReportAllAssertions = true;
-    }
+  XmlReporter::XmlReporter(ReporterConfig const &_config)
+      : StreamingReporterBase(_config), m_xml(_config.stream())
+  {
+    m_reporterPrefs.shouldRedirectStdOut      = true;
+    m_reporterPrefs.shouldReportAllAssertions = true;
+  }
 
-    XmlReporter::~XmlReporter() = default;
+  XmlReporter::~XmlReporter() = default;
 
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
+  std::string XmlReporter::getDescription() { return "Reports test results as an XML document"; }
 
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
+  std::string XmlReporter::getStylesheetRef() const { return std::string(); }
 
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename", sourceInfo.file )
-            .writeAttribute( "line", sourceInfo.line );
-    }
+  void XmlReporter::writeSourceInfo(SourceLineInfo const &sourceInfo)
+  {
+    m_xml.writeAttribute("filename", sourceInfo.file).writeAttribute("line", sourceInfo.line);
+  }
 
-    void XmlReporter::noMatchingTestCases( std::string const& s ) {
-        StreamingReporterBase::noMatchingTestCases( s );
-    }
+  void XmlReporter::noMatchingTestCases(std::string const &s)
+  {
+    StreamingReporterBase::noMatchingTestCases(s);
+  }
 
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement( "Catch" );
-        if( !m_config->name().empty() )
-            m_xml.writeAttribute( "name", m_config->name() );
-        if (m_config->testSpec().hasFilters())
-            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
-        if( m_config->rngSeed() != 0 )
-            m_xml.scopedElement( "Randomness" )
-                .writeAttribute( "seed", m_config->rngSeed() );
-    }
+  void XmlReporter::testRunStarting(TestRunInfo const &testInfo)
+  {
+    StreamingReporterBase::testRunStarting(testInfo);
+    std::string stylesheetRef = getStylesheetRef();
+    if (!stylesheetRef.empty())
+      m_xml.writeStylesheetRef(stylesheetRef);
+    m_xml.startElement("Catch");
+    if (!m_config->name().empty())
+      m_xml.writeAttribute("name", m_config->name());
+    if (m_config->testSpec().hasFilters())
+      m_xml.writeAttribute("filters", serializeFilters(m_config->getTestsOrTags()));
+    if (m_config->rngSeed() != 0)
+      m_xml.scopedElement("Randomness").writeAttribute("seed", m_config->rngSeed());
+  }
 
-    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        StreamingReporterBase::testGroupStarting( groupInfo );
-        m_xml.startElement( "Group" )
-            .writeAttribute( "name", groupInfo.name );
-    }
+  void XmlReporter::testGroupStarting(GroupInfo const &groupInfo)
+  {
+    StreamingReporterBase::testGroupStarting(groupInfo);
+    m_xml.startElement("Group").writeAttribute("name", groupInfo.name);
+  }
 
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name", trim( testInfo.name ) )
-            .writeAttribute( "description", testInfo.description )
-            .writeAttribute( "tags", testInfo.tagsAsString() );
+  void XmlReporter::testCaseStarting(TestCaseInfo const &testInfo)
+  {
+    StreamingReporterBase::testCaseStarting(testInfo);
+    m_xml.startElement("TestCase")
+        .writeAttribute("name", trim(testInfo.name))
+        .writeAttribute("description", testInfo.description)
+        .writeAttribute("tags", testInfo.tagsAsString());
 
-        writeSourceInfo( testInfo.lineInfo );
+    writeSourceInfo(testInfo.lineInfo);
 
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
+    if (m_config->showDurations() == ShowDurations::Always)
+      m_testCaseTimer.start();
+    m_xml.ensureTagClosed();
+  }
 
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
+  void XmlReporter::sectionStarting(SectionInfo const &sectionInfo)
+  {
+    StreamingReporterBase::sectionStarting(sectionInfo);
+    if (m_sectionDepth++ > 0) {
+      m_xml.startElement("Section").writeAttribute("name", trim(sectionInfo.name));
+      writeSourceInfo(sectionInfo.lineInfo);
+      m_xml.ensureTagClosed();
     }
+  }
 
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+  void XmlReporter::assertionStarting(AssertionInfo const &) {}
 
-    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+  bool XmlReporter::assertionEnded(AssertionStats const &assertionStats)
+  {
 
-        AssertionResult const& result = assertionStats.assertionResult;
+    AssertionResult const &result = assertionStats.assertionResult;
 
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
 
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    m_xml.scopedElement( "Info" )
-                            .writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    m_xml.scopedElement( "Warning" )
-                            .writeText( msg.message );
-                }
-            }
+    if (includeResults || result.getResultType() == ResultWas::Warning) {
+      // Print any info messages in <Info> tags.
+      for (auto const &msg : assertionStats.infoMessages) {
+        if (msg.type == ResultWas::Info && includeResults) {
+          m_xml.scopedElement("Info").writeText(msg.message);
         }
+        else if (msg.type == ResultWas::Warning) {
+          m_xml.scopedElement("Warning").writeText(msg.message);
+        }
+      }
+    }
 
-        // Drop out if result was successful but we're not printing them.
-        if( !includeResults && result.getResultType() != ResultWas::Warning )
-            return true;
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success", result.succeeded() )
-                .writeAttribute( "type", result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
+    // Drop out if result was successful but we're not printing them.
+    if (!includeResults && result.getResultType() != ResultWas::Warning)
+      return true;
+
+    // Print the expression if there is one.
+    if (result.hasExpression()) {
+      m_xml.startElement("Expression")
+          .writeAttribute("success", result.succeeded())
+          .writeAttribute("type", result.getTestMacroName());
+
+      writeSourceInfo(result.getSourceInfo());
+
+      m_xml.scopedElement("Original").writeText(result.getExpression());
+      m_xml.scopedElement("Expanded").writeText(result.getExpandedExpression());
+    }
+
+    // And... Print a result applicable to each result type.
+    switch (result.getResultType()) {
+    case ResultWas::ThrewException:
+      m_xml.startElement("Exception");
+      writeSourceInfo(result.getSourceInfo());
+      m_xml.writeText(result.getMessage());
+      m_xml.endElement();
+      break;
+    case ResultWas::FatalErrorCondition:
+      m_xml.startElement("FatalErrorCondition");
+      writeSourceInfo(result.getSourceInfo());
+      m_xml.writeText(result.getMessage());
+      m_xml.endElement();
+      break;
+    case ResultWas::Info: m_xml.scopedElement("Info").writeText(result.getMessage()); break;
+    case ResultWas::Warning:
+      // Warning will already have been written
+      break;
+    case ResultWas::ExplicitFailure:
+      m_xml.startElement("Failure");
+      writeSourceInfo(result.getSourceInfo());
+      m_xml.writeText(result.getMessage());
+      m_xml.endElement();
+      break;
+    default: break;
+    }
+
+    if (result.hasExpression())
+      m_xml.endElement();
 
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
+    return true;
+  }
 
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                    .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
+  void XmlReporter::sectionEnded(SectionStats const &sectionStats)
+  {
+    StreamingReporterBase::sectionEnded(sectionStats);
+    if (--m_sectionDepth > 0) {
+      XmlWriter::ScopedElement e = m_xml.scopedElement("OverallResults");
+      e.writeAttribute("successes", sectionStats.assertions.passed);
+      e.writeAttribute("failures", sectionStats.assertions.failed);
+      e.writeAttribute("expectedFailures", sectionStats.assertions.failedButOk);
 
-        if( result.hasExpression() )
-            m_xml.endElement();
+      if (m_config->showDurations() == ShowDurations::Always)
+        e.writeAttribute("durationInSeconds", sectionStats.durationInSeconds);
 
-        return true;
+      m_xml.endElement();
     }
+  }
 
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if( --m_sectionDepth > 0 ) {
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-            e.writeAttribute( "successes", sectionStats.assertions.passed );
-            e.writeAttribute( "failures", sectionStats.assertions.failed );
-            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+  void XmlReporter::testCaseEnded(TestCaseStats const &testCaseStats)
+  {
+    StreamingReporterBase::testCaseEnded(testCaseStats);
+    XmlWriter::ScopedElement e = m_xml.scopedElement("OverallResult");
+    e.writeAttribute("success", testCaseStats.totals.assertions.allOk());
 
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+    if (m_config->showDurations() == ShowDurations::Always)
+      e.writeAttribute("durationInSeconds", m_testCaseTimer.getElapsedSeconds());
 
-            m_xml.endElement();
-        }
-    }
+    if (!testCaseStats.stdOut.empty())
+      m_xml.scopedElement("StdOut").writeText(trim(testCaseStats.stdOut), false);
+    if (!testCaseStats.stdErr.empty())
+      m_xml.scopedElement("StdErr").writeText(trim(testCaseStats.stdErr), false);
 
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+    m_xml.endElement();
+  }
 
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+  void XmlReporter::testGroupEnded(TestGroupStats const &testGroupStats)
+  {
+    StreamingReporterBase::testGroupEnded(testGroupStats);
+    // TODO: Check testGroupStats.aborting and act accordingly.
+    m_xml.scopedElement("OverallResults")
+        .writeAttribute("successes", testGroupStats.totals.assertions.passed)
+        .writeAttribute("failures", testGroupStats.totals.assertions.failed)
+        .writeAttribute("expectedFailures", testGroupStats.totals.assertions.failedButOk);
+    m_xml.endElement();
+  }
 
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+  void XmlReporter::testRunEnded(TestRunStats const &testRunStats)
+  {
+    StreamingReporterBase::testRunEnded(testRunStats);
+    m_xml.scopedElement("OverallResults")
+        .writeAttribute("successes", testRunStats.totals.assertions.passed)
+        .writeAttribute("failures", testRunStats.totals.assertions.failed)
+        .writeAttribute("expectedFailures", testRunStats.totals.assertions.failedButOk);
+    m_xml.endElement();
+  }
 
-        m_xml.endElement();
-    }
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+  void XmlReporter::benchmarkPreparing(std::string const &name)
+  {
+    m_xml.startElement("BenchmarkResults").writeAttribute("name", name);
+  }
 
-    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        StreamingReporterBase::testGroupEnded( testGroupStats );
-        // TODO: Check testGroupStats.aborting and act accordingly.
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
+  void XmlReporter::benchmarkStarting(BenchmarkInfo const &info)
+  {
+    m_xml.writeAttribute("samples", info.samples)
+        .writeAttribute("resamples", info.resamples)
+        .writeAttribute("iterations", info.iterations)
+        .writeAttribute("clockResolution", static_cast<uint64_t>(info.clockResolution))
+        .writeAttribute("estimatedDuration", static_cast<uint64_t>(info.estimatedDuration))
+        .writeComment("All values in nano seconds");
+  }
 
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
+  void XmlReporter::benchmarkEnded(BenchmarkStats<> const &benchmarkStats)
+  {
+    m_xml.startElement("mean")
+        .writeAttribute("value", static_cast<uint64_t>(benchmarkStats.mean.point.count()))
+        .writeAttribute("lowerBound",
+                        static_cast<uint64_t>(benchmarkStats.mean.lower_bound.count()))
+        .writeAttribute("upperBound",
+                        static_cast<uint64_t>(benchmarkStats.mean.upper_bound.count()))
+        .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+    m_xml.endElement();
+    m_xml.startElement("standardDeviation")
+        .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+        .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+        .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+        .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+    m_xml.endElement();
+    m_xml.startElement("outliers")
+        .writeAttribute("variance", benchmarkStats.outlierVariance)
+        .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+        .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+        .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+        .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+    m_xml.endElement();
+    m_xml.endElement();
+  }
 
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void XmlReporter::benchmarkPreparing(std::string const& name) {
-        m_xml.startElement("BenchmarkResults")
-            .writeAttribute("name", name);
-    }
-
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.writeAttribute("samples", info.samples)
-            .writeAttribute("resamples", info.resamples)
-            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", static_cast<uint64_t>(info.clockResolution))
-            .writeAttribute("estimatedDuration", static_cast<uint64_t>(info.estimatedDuration))
-            .writeComment("All values in nano seconds");
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.startElement("mean")
-            .writeAttribute("value", static_cast<uint64_t>(benchmarkStats.mean.point.count()))
-            .writeAttribute("lowerBound", static_cast<uint64_t>(benchmarkStats.mean.lower_bound.count()))
-            .writeAttribute("upperBound", static_cast<uint64_t>(benchmarkStats.mean.upper_bound.count()))
-            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("standardDeviation")
-            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("outliers")
-            .writeAttribute("variance", benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(std::string const &error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message", error);
-        m_xml.endElement();
-    }
+  void XmlReporter::benchmarkFailed(std::string const &error)
+  {
+    m_xml.scopedElement("failed").writeAttribute("message", error);
+    m_xml.endElement();
+  }
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+  CATCH_REGISTER_REPORTER("xml", XmlReporter)
 
 } // end namespace Catch
 
@@ -16616,7 +17940,7 @@ namespace Catch {
 // end catch_reporter_xml.cpp
 
 namespace Catch {
-    LeakDetector leakDetector;
+  LeakDetector leakDetector;
 }
 
 #ifdef __clang__
@@ -16633,31 +17957,34 @@ namespace Catch {
 
 #if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
 // Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+extern "C" int wmain(int argc, wchar_t *argv[], wchar_t *[])
+{
 #else
 // Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
+int main(int argc, char *argv[])
+{
 #endif
 
-    return Catch::Session().run( argc, argv );
+  return Catch::Session().run(argc, argv);
 }
 
 #else // __OBJC__
 
 // Objective-C entry point
-int main (int argc, char * const argv[]) {
+int main(int argc, char *const argv[])
+{
 #if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 #endif
 
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
+  Catch::registerTestMethods();
+  int result = Catch::Session().run(argc, (char **)argv);
 
 #if !CATCH_ARC_ENABLED
-    [pool drain];
+  [pool drain];
 #endif
 
-    return result;
+  return result;
 }
 
 #endif // __OBJC__
@@ -16668,7 +17995,7 @@ int main (int argc, char * const argv[]) {
 #if !defined(CATCH_CONFIG_IMPL_ONLY)
 
 #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
+#undef CLARA_CONFIG_MAIN
 #endif
 
 #if !defined(CATCH_CONFIG_DISABLE)
@@ -16676,201 +18003,339 @@ int main (int argc, char * const argv[]) {
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL
 
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define CATCH_REQUIRE(...)                                                                         \
+  INTERNAL_CATCH_TEST("CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__)
+#define CATCH_REQUIRE_FALSE(...)                                                                   \
+  INTERNAL_CATCH_TEST("CATCH_REQUIRE_FALSE",                                                       \
+                      Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest,      \
+                      __VA_ARGS__)
+
+#define CATCH_REQUIRE_THROWS(...)                                                                  \
+  INTERNAL_CATCH_THROWS("CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__)
+#define CATCH_REQUIRE_THROWS_AS(expr, exceptionType)                                               \
+  INTERNAL_CATCH_THROWS_AS("CATCH_REQUIRE_THROWS_AS", exceptionType,                               \
+                           Catch::ResultDisposition::Normal, expr)
+#define CATCH_REQUIRE_THROWS_WITH(expr, matcher)                                                   \
+  INTERNAL_CATCH_THROWS_STR_MATCHES("CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, \
+                                    matcher, expr)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CATCH_REQUIRE_THROWS_MATCHES(expr, exceptionType, matcher)                                 \
+  INTERNAL_CATCH_THROWS_MATCHES("CATCH_REQUIRE_THROWS_MATCHES", exceptionType,                     \
+                                Catch::ResultDisposition::Normal, matcher, expr)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW(...)                                                                 \
+  INTERNAL_CATCH_NO_THROW("CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__)
+
+#define CATCH_CHECK(...)                                                                           \
+  INTERNAL_CATCH_TEST("CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CATCH_CHECK_FALSE(...)                                                                     \
+  INTERNAL_CATCH_TEST("CATCH_CHECK_FALSE",                                                         \
+                      Catch::ResultDisposition::ContinueOnFailure |                                \
+                          Catch::ResultDisposition::FalseTest,                                     \
+                      __VA_ARGS__)
+#define CATCH_CHECKED_IF(...)                                                                      \
+  INTERNAL_CATCH_IF("CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CATCH_CHECKED_ELSE(...)                                                                    \
+  INTERNAL_CATCH_ELSE("CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure,           \
+                      __VA_ARGS__)
+#define CATCH_CHECK_NOFAIL(...)                                                                    \
+  INTERNAL_CATCH_TEST("CATCH_CHECK_NOFAIL",                                                        \
+                      Catch::ResultDisposition::ContinueOnFailure |                                \
+                          Catch::ResultDisposition::SuppressFail,                                  \
+                      __VA_ARGS__)
+
+#define CATCH_CHECK_THROWS(...)                                                                    \
+  INTERNAL_CATCH_THROWS("CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure,         \
+                        __VA_ARGS__)
+#define CATCH_CHECK_THROWS_AS(expr, exceptionType)                                                 \
+  INTERNAL_CATCH_THROWS_AS("CATCH_CHECK_THROWS_AS", exceptionType,                                 \
+                           Catch::ResultDisposition::ContinueOnFailure, expr)
+#define CATCH_CHECK_THROWS_WITH(expr, matcher)                                                     \
+  INTERNAL_CATCH_THROWS_STR_MATCHES("CATCH_CHECK_THROWS_WITH",                                     \
+                                    Catch::ResultDisposition::ContinueOnFailure, matcher, expr)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CATCH_CHECK_THROWS_MATCHES(expr, exceptionType, matcher)                                   \
+  INTERNAL_CATCH_THROWS_MATCHES("CATCH_CHECK_THROWS_MATCHES", exceptionType,                       \
+                                Catch::ResultDisposition::ContinueOnFailure, matcher, expr)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_NOTHROW(...)                                                                   \
+  INTERNAL_CATCH_NO_THROW("CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure,      \
+                          __VA_ARGS__)
 
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+#define CATCH_CHECK_THAT(arg, matcher)                                                             \
+  INTERNAL_CHECK_THAT("CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg)
 
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#define CATCH_REQUIRE_THAT(arg, matcher)                                                           \
+  INTERNAL_CHECK_THAT("CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_INFO(msg) INTERNAL_CATCH_INFO("CATCH_INFO", msg)
+#define CATCH_UNSCOPED_INFO(msg) INTERNAL_CATCH_UNSCOPED_INFO("CATCH_UNSCOPED_INFO", msg)
+#define CATCH_WARN(msg)                                                                            \
+  INTERNAL_CATCH_MSG("CATCH_WARN", Catch::ResultWas::Warning,                                      \
+                     Catch::ResultDisposition::ContinueOnFailure, msg)
+#define CATCH_CAPTURE(...)                                                                         \
+  INTERNAL_CATCH_CAPTURE(INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__)
+
+#define CATCH_TEST_CASE(...) INTERNAL_CATCH_TESTCASE(__VA_ARGS__)
+#define CATCH_TEST_CASE_METHOD(className, ...)                                                     \
+  INTERNAL_CATCH_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define CATCH_METHOD_AS_TEST_CASE(method, ...)                                                     \
+  INTERNAL_CATCH_METHOD_AS_TEST_CASE(method, __VA_ARGS__)
+#define CATCH_REGISTER_TEST_CASE(Function, ...)                                                    \
+  INTERNAL_CATCH_REGISTER_TESTCASE(Function, __VA_ARGS__)
+#define CATCH_SECTION(...) INTERNAL_CATCH_SECTION(__VA_ARGS__)
+#define CATCH_DYNAMIC_SECTION(...) INTERNAL_CATCH_DYNAMIC_SECTION(__VA_ARGS__)
+#define CATCH_FAIL(...)                                                                            \
+  INTERNAL_CATCH_MSG("CATCH_FAIL", Catch::ResultWas::ExplicitFailure,                              \
+                     Catch::ResultDisposition::Normal, __VA_ARGS__)
+#define CATCH_FAIL_CHECK(...)                                                                      \
+  INTERNAL_CATCH_MSG("CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure,                        \
+                     Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CATCH_SUCCEED(...)                                                                         \
+  INTERNAL_CATCH_MSG("CATCH_SUCCEED", Catch::ResultWas::Ok,                                        \
+                     Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
 
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG(...) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD(className, ...)                                            \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                        \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(__VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(...)                                                  \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(__VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                    \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, __VA_ARGS__)
 #else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE(...)                                                              \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__))
+#define CATCH_TEMPLATE_TEST_CASE_SIG(...)                                                          \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(__VA_ARGS__))
+#define CATCH_TEMPLATE_TEST_CASE_METHOD(className, ...)                                            \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__))
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                        \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, __VA_ARGS__))
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE(...)                                                      \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(__VA_ARGS__))
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(...)                                                  \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(__VA_ARGS__))
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                    \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, __VA_ARGS__))
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, __VA_ARGS__))
 #endif
 
 #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE(...)                                                                  \
+  static_assert(__VA_ARGS__, #__VA_ARGS__);                                                        \
+  CATCH_SUCCEED(#__VA_ARGS__)
+#define CATCH_STATIC_REQUIRE_FALSE(...)                                                            \
+  static_assert(!(__VA_ARGS__), "!(" #__VA_ARGS__ ")");                                            \
+  CATCH_SUCCEED(#__VA_ARGS__)
 #else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE(...) CATCH_REQUIRE(__VA_ARGS__)
+#define CATCH_STATIC_REQUIRE_FALSE(...) CATCH_REQUIRE_FALSE(__VA_ARGS__)
 #endif
 
 // "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+#define CATCH_SCENARIO(...) CATCH_TEST_CASE("Scenario: " __VA_ARGS__)
+#define CATCH_SCENARIO_METHOD(className, ...)                                                      \
+  INTERNAL_CATCH_TEST_CASE_METHOD(className, "Scenario: " __VA_ARGS__)
+#define CATCH_GIVEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("    Given: " << desc)
+#define CATCH_AND_GIVEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("And given: " << desc)
+#define CATCH_WHEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("     When: " << desc)
+#define CATCH_AND_WHEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION(" And when: " << desc)
+#define CATCH_THEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("     Then: " << desc)
+#define CATCH_AND_THEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("      And: " << desc)
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#define CATCH_BENCHMARK(...)                                                                       \
+  INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____),             \
+                           INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__, , ),                              \
+                           INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__, , ))
+#define CATCH_BENCHMARK_ADVANCED(name)                                                             \
+  INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____),    \
+                                    name)
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define REQUIRE(...) INTERNAL_CATCH_TEST("REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__)
+#define REQUIRE_FALSE(...)                                                                         \
+  INTERNAL_CATCH_TEST("REQUIRE_FALSE",                                                             \
+                      Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest,      \
+                      __VA_ARGS__)
+
+#define REQUIRE_THROWS(...)                                                                        \
+  INTERNAL_CATCH_THROWS("REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__)
+#define REQUIRE_THROWS_AS(expr, exceptionType)                                                     \
+  INTERNAL_CATCH_THROWS_AS("REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal,   \
+                           expr)
+#define REQUIRE_THROWS_WITH(expr, matcher)                                                         \
+  INTERNAL_CATCH_THROWS_STR_MATCHES("REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal,       \
+                                    matcher, expr)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#define REQUIRE_THROWS_MATCHES(expr, exceptionType, matcher)                                       \
+  INTERNAL_CATCH_THROWS_MATCHES("REQUIRE_THROWS_MATCHES", exceptionType,                           \
+                                Catch::ResultDisposition::Normal, matcher, expr)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define REQUIRE_NOTHROW(...)                                                                       \
+  INTERNAL_CATCH_NO_THROW("REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__)
+
+#define CHECK(...)                                                                                 \
+  INTERNAL_CATCH_TEST("CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CHECK_FALSE(...)                                                                           \
+  INTERNAL_CATCH_TEST("CHECK_FALSE",                                                               \
+                      Catch::ResultDisposition::ContinueOnFailure |                                \
+                          Catch::ResultDisposition::FalseTest,                                     \
+                      __VA_ARGS__)
+#define CHECKED_IF(...)                                                                            \
+  INTERNAL_CATCH_IF("CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CHECKED_ELSE(...)                                                                          \
+  INTERNAL_CATCH_ELSE("CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CHECK_NOFAIL(...)                                                                          \
+  INTERNAL_CATCH_TEST("CHECK_NOFAIL",                                                              \
+                      Catch::ResultDisposition::ContinueOnFailure |                                \
+                          Catch::ResultDisposition::SuppressFail,                                  \
+                      __VA_ARGS__)
+
+#define CHECK_THROWS(...)                                                                          \
+  INTERNAL_CATCH_THROWS("CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define CHECK_THROWS_AS(expr, exceptionType)                                                       \
+  INTERNAL_CATCH_THROWS_AS("CHECK_THROWS_AS", exceptionType,                                       \
+                           Catch::ResultDisposition::ContinueOnFailure, expr)
+#define CHECK_THROWS_WITH(expr, matcher)                                                           \
+  INTERNAL_CATCH_THROWS_STR_MATCHES("CHECK_THROWS_WITH",                                           \
+                                    Catch::ResultDisposition::ContinueOnFailure, matcher, expr)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CHECK_THROWS_MATCHES(expr, exceptionType, matcher)                                         \
+  INTERNAL_CATCH_THROWS_MATCHES("CHECK_THROWS_MATCHES", exceptionType,                             \
+                                Catch::ResultDisposition::ContinueOnFailure, matcher, expr)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_NOTHROW(...)                                                                         \
+  INTERNAL_CATCH_NO_THROW("CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
 
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+#define CHECK_THAT(arg, matcher)                                                                   \
+  INTERNAL_CHECK_THAT("CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg)
 
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#define REQUIRE_THAT(arg, matcher)                                                                 \
+  INTERNAL_CHECK_THAT("REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define INFO(msg) INTERNAL_CATCH_INFO("INFO", msg)
+#define UNSCOPED_INFO(msg) INTERNAL_CATCH_UNSCOPED_INFO("UNSCOPED_INFO", msg)
+#define WARN(msg)                                                                                  \
+  INTERNAL_CATCH_MSG("WARN", Catch::ResultWas::Warning,                                            \
+                     Catch::ResultDisposition::ContinueOnFailure, msg)
+#define CAPTURE(...)                                                                               \
+  INTERNAL_CATCH_CAPTURE(INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__)
+
+#define TEST_CASE(...) INTERNAL_CATCH_TESTCASE(__VA_ARGS__)
+#define TEST_CASE_METHOD(className, ...) INTERNAL_CATCH_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define METHOD_AS_TEST_CASE(method, ...) INTERNAL_CATCH_METHOD_AS_TEST_CASE(method, __VA_ARGS__)
+#define REGISTER_TEST_CASE(Function, ...) INTERNAL_CATCH_REGISTER_TESTCASE(Function, __VA_ARGS__)
+#define SECTION(...) INTERNAL_CATCH_SECTION(__VA_ARGS__)
+#define DYNAMIC_SECTION(...) INTERNAL_CATCH_DYNAMIC_SECTION(__VA_ARGS__)
+#define FAIL(...)                                                                                  \
+  INTERNAL_CATCH_MSG("FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal,  \
+                     __VA_ARGS__)
+#define FAIL_CHECK(...)                                                                            \
+  INTERNAL_CATCH_MSG("FAIL_CHECK", Catch::ResultWas::ExplicitFailure,                              \
+                     Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__)
+#define SUCCEED(...)                                                                               \
+  INTERNAL_CATCH_MSG("SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, \
+                     __VA_ARGS__)
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG(...) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD(className, ...)                                                  \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                              \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, __VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG(...)                                                        \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(__VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                          \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                      \
+  INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, __VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD(className, ...)                                             \
+  INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(className, __VA_ARGS__)
 #else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE(...)                                                                    \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__))
+#define TEMPLATE_TEST_CASE_SIG(...)                                                                \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(__VA_ARGS__))
+#define TEMPLATE_TEST_CASE_METHOD(className, ...)                                                  \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__))
+#define TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                              \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, __VA_ARGS__))
+#define TEMPLATE_PRODUCT_TEST_CASE(...)                                                            \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(__VA_ARGS__))
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG(...)                                                        \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(__VA_ARGS__))
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                          \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, __VA_ARGS__))
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                      \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, __VA_ARGS__))
+#define TEMPLATE_LIST_TEST_CASE(...)                                                               \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__))
+#define TEMPLATE_LIST_TEST_CASE_METHOD(className, ...)                                             \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(className, __VA_ARGS__))
 #endif
 
 #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#define STATIC_REQUIRE(...)                                                                        \
+  static_assert(__VA_ARGS__, #__VA_ARGS__);                                                        \
+  SUCCEED(#__VA_ARGS__)
+#define STATIC_REQUIRE_FALSE(...)                                                                  \
+  static_assert(!(__VA_ARGS__), "!(" #__VA_ARGS__ ")");                                            \
+  SUCCEED("!(" #__VA_ARGS__ ")")
 #else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#define STATIC_REQUIRE(...) REQUIRE(__VA_ARGS__)
+#define STATIC_REQUIRE_FALSE(...) REQUIRE_FALSE(__VA_ARGS__)
 #endif
 
 #endif
 
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+#define CATCH_TRANSLATE_EXCEPTION(signature) INTERNAL_CATCH_TRANSLATE_EXCEPTION(signature)
 
 // "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#define SCENARIO(...) TEST_CASE("Scenario: " __VA_ARGS__)
+#define SCENARIO_METHOD(className, ...)                                                            \
+  INTERNAL_CATCH_TEST_CASE_METHOD(className, "Scenario: " __VA_ARGS__)
 
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+#define GIVEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("    Given: " << desc)
+#define AND_GIVEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("And given: " << desc)
+#define WHEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("     When: " << desc)
+#define AND_WHEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION(" And when: " << desc)
+#define THEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("     Then: " << desc)
+#define AND_THEN(desc) INTERNAL_CATCH_DYNAMIC_SECTION("      And: " << desc)
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#define BENCHMARK(...)                                                                             \
+  INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____),             \
+                           INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__, , ),                              \
+                           INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__, , ))
+#define BENCHMARK_ADVANCED(name)                                                                   \
+  INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____),    \
+                                    name)
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 using Catch::Detail::Approx;
@@ -16881,174 +18346,214 @@ using Catch::Detail::Approx;
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL
 
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+#define CATCH_REQUIRE(...) (void)(0)
+#define CATCH_REQUIRE_FALSE(...) (void)(0)
 
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
+#define CATCH_REQUIRE_THROWS(...) (void)(0)
+#define CATCH_REQUIRE_THROWS_AS(expr, exceptionType) (void)(0)
+#define CATCH_REQUIRE_THROWS_WITH(expr, matcher) (void)(0)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#define CATCH_REQUIRE_THROWS_MATCHES(expr, exceptionType, matcher) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+#define CATCH_REQUIRE_NOTHROW(...) (void)(0)
 
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+#define CATCH_CHECK(...) (void)(0)
+#define CATCH_CHECK_FALSE(...) (void)(0)
+#define CATCH_CHECKED_IF(...) if (__VA_ARGS__)
+#define CATCH_CHECKED_ELSE(...) if (!(__VA_ARGS__))
+#define CATCH_CHECK_NOFAIL(...) (void)(0)
 
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#define CATCH_CHECK_THROWS(...) (void)(0)
+#define CATCH_CHECK_THROWS_AS(expr, exceptionType) (void)(0)
+#define CATCH_CHECK_THROWS_WITH(expr, matcher) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES(expr, exceptionType, matcher) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW(...) (void)(0)
 
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT(arg, matcher) (void)(0)
 
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
+#define CATCH_REQUIRE_THAT(arg, matcher) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
 
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_INFO(msg) (void)(0)
+#define CATCH_UNSCOPED_INFO(msg) (void)(0)
+#define CATCH_WARN(msg) (void)(0)
+#define CATCH_CAPTURE(msg) (void)(0)
+
+#define CATCH_TEST_CASE(...)                                                                       \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
+#define CATCH_TEST_CASE_METHOD(className, ...)                                                     \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
+#define CATCH_METHOD_AS_TEST_CASE(method, ...)
+#define CATCH_REGISTER_TEST_CASE(Function, ...) (void)(0)
+#define CATCH_SECTION(...)
+#define CATCH_DYNAMIC_SECTION(...)
+#define CATCH_FAIL(...) (void)(0)
+#define CATCH_FAIL_CHECK(...) (void)(0)
+#define CATCH_SUCCEED(...) (void)(0)
+
+#define CATCH_ANON_TEST_CASE()                                                                     \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG(...)                                                          \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD(className, ...)                                            \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                        \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE(...) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(...) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                    \
+  CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                \
+  CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
 #else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE(...)                                                              \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__))
+#define CATCH_TEMPLATE_TEST_CASE_SIG(...)                                                          \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__))
+#define CATCH_TEMPLATE_TEST_CASE_METHOD(className, ...)                                            \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__))
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                        \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__))
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE(...) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(...) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                    \
+  CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                \
+  CATCH_TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
 #endif
 
 // "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+#define CATCH_SCENARIO(...)                                                                        \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
+#define CATCH_SCENARIO_METHOD(className, ...)                                                      \
+  INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(                                                  \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____), className)
+#define CATCH_GIVEN(desc)
+#define CATCH_AND_GIVEN(desc)
+#define CATCH_WHEN(desc)
+#define CATCH_AND_WHEN(desc)
+#define CATCH_THEN(desc)
+#define CATCH_AND_THEN(desc)
+
+#define CATCH_STATIC_REQUIRE(...) (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE(...) (void)(0)
 
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
+#define REQUIRE(...) (void)(0)
+#define REQUIRE_FALSE(...) (void)(0)
 
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#define REQUIRE_THROWS(...) (void)(0)
+#define REQUIRE_THROWS_AS(expr, exceptionType) (void)(0)
+#define REQUIRE_THROWS_WITH(expr, matcher) (void)(0)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#define REQUIRE_THROWS_MATCHES(expr, exceptionType, matcher) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
+#define REQUIRE_NOTHROW(...) (void)(0)
 
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
+#define CHECK(...) (void)(0)
+#define CHECK_FALSE(...) (void)(0)
+#define CHECKED_IF(...) if (__VA_ARGS__)
+#define CHECKED_ELSE(...) if (!(__VA_ARGS__))
+#define CHECK_NOFAIL(...) (void)(0)
 
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+#define CHECK_THROWS(...) (void)(0)
+#define CHECK_THROWS_AS(expr, exceptionType) (void)(0)
+#define CHECK_THROWS_WITH(expr, matcher) (void)(0)
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#define CHECK_THROWS_MATCHES(expr, exceptionType, matcher) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
+#define CHECK_NOTHROW(...) (void)(0)
 
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
+#define CHECK_THAT(arg, matcher) (void)(0)
 
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#define REQUIRE_THAT(arg, matcher) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define INFO(msg) (void)(0)
+#define UNSCOPED_INFO(msg) (void)(0)
+#define WARN(msg) (void)(0)
+#define CAPTURE(msg) (void)(0)
+
+#define TEST_CASE(...)                                                                             \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
+#define TEST_CASE_METHOD(className, ...)                                                           \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
+#define METHOD_AS_TEST_CASE(method, ...)
+#define REGISTER_TEST_CASE(Function, ...) (void)(0)
+#define SECTION(...)
+#define DYNAMIC_SECTION(...)
+#define FAIL(...) (void)(0)
+#define FAIL_CHECK(...) (void)(0)
+#define SUCCEED(...) (void)(0)
+#define ANON_TEST_CASE()                                                                           \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
 
 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE(...) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG(...)                                                                \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD(className, ...)                                                  \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                              \
+  INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE(...) TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG(...) TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                          \
+  TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                      \
+  TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
 #else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE(...)                                                                    \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__))
+#define TEMPLATE_TEST_CASE_SIG(...)                                                                \
+  INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__))
+#define TEMPLATE_TEST_CASE_METHOD(className, ...)                                                  \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__))
+#define TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)                                              \
+  INTERNAL_CATCH_EXPAND_VARGS(                                                                     \
+      INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__))
+#define TEMPLATE_PRODUCT_TEST_CASE(...) TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG(...) TEMPLATE_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)                                          \
+  TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)                                      \
+  TEMPLATE_TEST_CASE_METHOD(className, __VA_ARGS__)
 #endif
 
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+#define STATIC_REQUIRE(...) (void)(0)
+#define STATIC_REQUIRE_FALSE(...) (void)(0)
 
 #endif
 
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+#define CATCH_TRANSLATE_EXCEPTION(signature)                                                       \
+  INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG(                                                       \
+      INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionTranslator), signature)
 
 // "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
+#define SCENARIO(...)                                                                              \
+  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____))
+#define SCENARIO_METHOD(className, ...)                                                            \
+  INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(                                                  \
+      INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____), className)
+
+#define GIVEN(desc)
+#define AND_GIVEN(desc)
+#define WHEN(desc)
+#define AND_WHEN(desc)
+#define THEN(desc)
+#define AND_THEN(desc)
 
 using Catch::Detail::Approx;
 
@@ -17058,18 +18563,16 @@ using Catch::Detail::Approx;
 
 // start catch_reenable_warnings.h
 
-
 #ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
+#ifdef __ICC // icpc defines the __clang__ macro
+#pragma warning(pop)
+#else
+#pragma clang diagnostic pop
+#endif
+#elif defined          __GNUC__
+#pragma GCC diagnostic pop
 #endif
 
 // end catch_reenable_warnings.h
 // end catch.hpp
 #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/packages/seacas/libraries/ioss/src/cgns/Iocgns_DecompositionData.C b/packages/seacas/libraries/ioss/src/cgns/Iocgns_DecompositionData.C
index 8839a89181fe..274a158f03b2 100644
--- a/packages/seacas/libraries/ioss/src/cgns/Iocgns_DecompositionData.C
+++ b/packages/seacas/libraries/ioss/src/cgns/Iocgns_DecompositionData.C
@@ -321,9 +321,7 @@ namespace Iocgns {
               zone->m_name, zone->m_zone, zone->m_proc, zone->m_adam->m_zone, zone->work(),
               zone_node_count);
           auto zgcs = zone->m_zoneConnectivity;
-          for (auto &zgc : zgcs) {
-            fmt::print(stderr, "{}\n", zgc);
-          }
+          fmt::print(stderr, "{}\n", fmt::join(zgcs.begin(), zgcs.end(), "\n"));
         }
 #endif
       }
@@ -1081,8 +1079,7 @@ namespace Iocgns {
 
     if (!m_zoneSharedMap.empty()) {
       for (auto &node : file_conn) {
-        ZoneSharedMap::const_iterator alias =
-            m_zoneSharedMap.find(node - 1);
+        ZoneSharedMap::const_iterator alias = m_zoneSharedMap.find(node - 1);
         if (alias != m_zoneSharedMap.end()) {
           node = (*alias).second + 1;
         }
diff --git a/packages/seacas/libraries/ioss/src/cgns/Iocgns_Utils.C b/packages/seacas/libraries/ioss/src/cgns/Iocgns_Utils.C
index e3868a24f500..bc40348067f2 100644
--- a/packages/seacas/libraries/ioss/src/cgns/Iocgns_Utils.C
+++ b/packages/seacas/libraries/ioss/src/cgns/Iocgns_Utils.C
@@ -856,7 +856,7 @@ size_t Iocgns::Utils::common_write_meta_data(int file_ptr, const Ioss::Region &r
     // and "ser43") on certain ranks which caused an HDF5 failure way
     // downstream -- basically at file close.
     char tmp[2048];
-    Ioss::Utils::copy_string(tmp, version.c_str(), 2048);
+    Ioss::Utils::copy_string(tmp, version, 2048);
     MPI_Bcast(tmp, (int)version.size() + 1, MPI_BYTE, 0,
               region.get_database()->util().communicator());
     version = std::string{tmp};
diff --git a/packages/seacas/libraries/ioss/src/exo_fpp/Iofx_DatabaseIO.C b/packages/seacas/libraries/ioss/src/exo_fpp/Iofx_DatabaseIO.C
index a906839d94b9..bf9d92dbdf8d 100644
--- a/packages/seacas/libraries/ioss/src/exo_fpp/Iofx_DatabaseIO.C
+++ b/packages/seacas/libraries/ioss/src/exo_fpp/Iofx_DatabaseIO.C
@@ -932,7 +932,7 @@ namespace Iofx {
             Ioex::exodus_error(get_file_pointer(), __LINE__, __func__, __FILE__);
           }
 
-          if (map_count == 1 && Ioss::Utils::case_strcmp(names[0], "original_global_id_map") == 0) {
+          if (map_count == 1 && Ioss::Utils::str_equal(names[0], "original_global_id_map")) {
             int error = 0;
             if ((ex_int64_status(get_file_pointer()) & EX_BULK_INT64_API) != 0) {
               Ioss::Int64Vector tmp_map(entity_map.size());
diff --git a/packages/seacas/libraries/ioss/src/exo_par/Iopx_DatabaseIO.C b/packages/seacas/libraries/ioss/src/exo_par/Iopx_DatabaseIO.C
index e921151700e7..a91cab61f2ee 100644
--- a/packages/seacas/libraries/ioss/src/exo_par/Iopx_DatabaseIO.C
+++ b/packages/seacas/libraries/ioss/src/exo_par/Iopx_DatabaseIO.C
@@ -801,7 +801,7 @@ namespace Iopx {
             Ioex::exodus_error(get_file_pointer(), __LINE__, __func__, __FILE__);
           }
 
-          if (map_count == 1 && Ioss::Utils::case_strcmp(names[0], "original_global_id_map") == 0) {
+          if (map_count == 1 && Ioss::Utils::str_equal(names[0], "original_global_id_map")) {
             if (int_byte_size_api() == 8) {
               error = ex_get_partial_num_map(get_file_pointer(), entity_type, 1, file_offset + 1,
                                              file_count, TOPTR(file_data));
diff --git a/packages/seacas/libraries/ioss/src/exodus/Ioex_DatabaseIO.C b/packages/seacas/libraries/ioss/src/exodus/Ioex_DatabaseIO.C
index bb86609f8e55..4e9be9ec5f90 100644
--- a/packages/seacas/libraries/ioss/src/exodus/Ioex_DatabaseIO.C
+++ b/packages/seacas/libraries/ioss/src/exodus/Ioex_DatabaseIO.C
@@ -1818,7 +1818,7 @@ namespace Ioex {
         // NOTE: This must appear before the "sphere" check since
         // sphere is substring of "sphere-mass"
         // Want an exact match here, not substring match...
-        else if (Ioss::Utils::case_strcmp(type, "sphere-mass") == 0) {
+        else if (Ioss::Utils::str_equal(type, "sphere-mass")) {
           if (attribute_count != 10) {
             if (myProcessor == 0) {
               fmt::print(IOSS_WARNING,
diff --git a/packages/seacas/libraries/ioss/src/exodus/Ioex_Internals.h b/packages/seacas/libraries/ioss/src/exodus/Ioex_Internals.h
index c2ae2823c61a..fcda87790b37 100644
--- a/packages/seacas/libraries/ioss/src/exodus/Ioex_Internals.h
+++ b/packages/seacas/libraries/ioss/src/exodus/Ioex_Internals.h
@@ -165,12 +165,7 @@ namespace Ioex {
 
   struct FaceBlock
   {
-    FaceBlock()
-        : name(""), id(0), entityCount(0), nodesPerEntity(0), edgesPerEntity(0), attributeCount(0),
-          procOffset(0)
-    {
-      Ioss::Utils::copy_string(elType, "");
-    }
+    FaceBlock() { Ioss::Utils::copy_string(elType, ""); }
 
     FaceBlock(const FaceBlock &other)
         : name(other.name), id(other.id), entityCount(other.entityCount),
@@ -190,25 +185,20 @@ namespace Ioex {
     bool operator!=(const FaceBlock &other) const { return !(*this == other); }
 
     char        elType[MAX_STR_LENGTH + 1]{};
-    std::string name;
-    entity_id   id;
-    int64_t     entityCount;
-    int64_t     nodesPerEntity;
-    int64_t     edgesPerEntity;
-    int64_t     attributeCount;
-    int64_t     procOffset;
+    std::string name{};
+    entity_id   id{0};
+    int64_t     entityCount{0};
+    int64_t     nodesPerEntity{0};
+    int64_t     edgesPerEntity{0};
+    int64_t     attributeCount{0};
+    int64_t     procOffset{0};
 
   private:
   };
 
   struct ElemBlock
   {
-    ElemBlock()
-        : name(""), id(0), entityCount(0), nodesPerEntity(0), edgesPerEntity(0), facesPerEntity(0),
-          attributeCount(0), offset_(-1), procOffset(0)
-    {
-      Ioss::Utils::copy_string(elType, "");
-    }
+    ElemBlock() { Ioss::Utils::copy_string(elType, ""); }
 
     ElemBlock(const ElemBlock &other)
         : name(other.name), id(other.id), entityCount(other.entityCount),
@@ -229,15 +219,15 @@ namespace Ioex {
     bool operator!=(const ElemBlock &other) const { return !(*this == other); }
 
     char        elType[MAX_STR_LENGTH + 1]{};
-    std::string name;
-    entity_id   id;
-    int64_t     entityCount;
-    int64_t     nodesPerEntity;
-    int64_t     edgesPerEntity;
-    int64_t     facesPerEntity;
-    int64_t     attributeCount;
-    int64_t     offset_;
-    int64_t     procOffset;
+    std::string name{};
+    entity_id   id{0};
+    int64_t     entityCount{0};
+    int64_t     nodesPerEntity{0};
+    int64_t     edgesPerEntity{0};
+    int64_t     facesPerEntity{0};
+    int64_t     attributeCount{0};
+    int64_t     offset_{-1};
+    int64_t     procOffset{0};
   };
 
   struct NodeSet
@@ -337,29 +327,23 @@ namespace Ioex {
 
   struct CommunicationMetaData
   {
-    CommunicationMetaData()
-        : processorId(0), processorCount(0), globalNodes(0), globalElements(0),
-          globalElementBlocks(0), globalNodeSets(0), globalSideSets(0), nodesInternal(0),
-          nodesBorder(0), nodesExternal(0), elementsInternal(0), elementsBorder(0),
-          outputNemesis(false)
-    {
-    }
+    CommunicationMetaData() = default;
 
     std::vector<CommunicationMap> nodeMap;
     std::vector<CommunicationMap> elementMap;
-    int                           processorId;
-    int                           processorCount;
-    int64_t                       globalNodes;
-    int64_t                       globalElements;
-    int64_t                       globalElementBlocks;
-    int64_t                       globalNodeSets;
-    int64_t                       globalSideSets;
-    int64_t                       nodesInternal;
-    int64_t                       nodesBorder;
-    int64_t                       nodesExternal;
-    int64_t                       elementsInternal;
-    int64_t                       elementsBorder;
-    bool                          outputNemesis;
+    int                           processorId{0};
+    int                           processorCount{0};
+    int64_t                       globalNodes{0};
+    int64_t                       globalElements{0};
+    int64_t                       globalElementBlocks{0};
+    int64_t                       globalNodeSets{0};
+    int64_t                       globalSideSets{0};
+    int64_t                       nodesInternal{0};
+    int64_t                       nodesBorder{0};
+    int64_t                       nodesExternal{0};
+    int64_t                       elementsInternal{0};
+    int64_t                       elementsBorder{0};
+    bool                          outputNemesis{false};
 
   private:
     CommunicationMetaData(const CommunicationMetaData &);
@@ -380,7 +364,7 @@ namespace Ioex {
   class Mesh
   {
   public:
-    Mesh() : title(), dimensionality(0), file_per_processor(true) {}
+    Mesh() = default;
 
     Mesh(int dim, char *the_title, bool file_pp) : dimensionality(dim), file_per_processor(file_pp)
     {
@@ -390,8 +374,8 @@ namespace Ioex {
     void populate(Ioss::Region *region);
 
     char title[MAX_LINE_LENGTH + 1]{};
-    int  dimensionality;
-    bool file_per_processor;
+    int  dimensionality{};
+    bool file_per_processor{true};
 
     std::vector<NodeBlock> nodeblocks;
     std::vector<EdgeBlock> edgeblocks;
diff --git a/packages/seacas/libraries/ioss/src/exodus/Ioex_SuperElement.C b/packages/seacas/libraries/ioss/src/exodus/Ioex_SuperElement.C
index 4c03c0d8ce20..f8c3fbd90ec8 100644
--- a/packages/seacas/libraries/ioss/src/exodus/Ioex_SuperElement.C
+++ b/packages/seacas/libraries/ioss/src/exodus/Ioex_SuperElement.C
@@ -289,19 +289,19 @@ int64_t Ioex::SuperElement::internal_put_field_data(const Ioss::Field & /* field
 
 Ioss::Property Ioex::SuperElement::get_implicit_property(const std::string &the_name) const
 {
-  if (Ioss::Utils::case_strcmp(the_name, "numDOF") == 0) {
+  if (Ioss::Utils::str_equal(the_name, "numDOF")) {
     return Ioss::Property(the_name, static_cast<int>(numDOF));
   }
-  if (Ioss::Utils::case_strcmp(the_name, "num_nodes") == 0) {
+  if (Ioss::Utils::str_equal(the_name, "num_nodes")) {
     return Ioss::Property(the_name, static_cast<int>(num_nodes));
   }
-  if (Ioss::Utils::case_strcmp(the_name, "numEIG") == 0) {
+  if (Ioss::Utils::str_equal(the_name, "numEIG")) {
     return Ioss::Property(the_name, static_cast<int>(numEIG));
   }
-  if (Ioss::Utils::case_strcmp(the_name, "num_dim") == 0) {
+  if (Ioss::Utils::str_equal(the_name, "num_dim")) {
     return Ioss::Property(the_name, static_cast<int>(num_dim));
   }
-  if (Ioss::Utils::case_strcmp(the_name, "numConstraints") == 0) {
+  if (Ioss::Utils::str_equal(the_name, "numConstraints")) {
     return Ioss::Property(the_name, static_cast<int>(numDOF) - static_cast<int>(numEIG));
   }
 
diff --git a/packages/seacas/libraries/ioss/src/exodus/Ioex_Utils.C b/packages/seacas/libraries/ioss/src/exodus/Ioex_Utils.C
index 75ebb46cfe07..36ec0f8e3c75 100644
--- a/packages/seacas/libraries/ioss/src/exodus/Ioex_Utils.C
+++ b/packages/seacas/libraries/ioss/src/exodus/Ioex_Utils.C
@@ -34,6 +34,7 @@
 #include <Ioss_Region.h>
 #include <Ioss_Utils.h>
 #include <Ioss_VariableType.h>
+#include <Ioss_Version.h>
 #include <algorithm>
 #include <cstring>
 #include <exodus/Ioex_Utils.h>
@@ -115,7 +116,7 @@ namespace {
 } // namespace
 
 namespace Ioex {
-  const char *Version() { return "2016/05/25"; }
+  const char *Version() { return Ioss::Version(); }
 
   void update_last_time_attribute(int exodusFilePtr, double value)
   {
diff --git a/packages/seacas/libraries/ioss/src/fmt/chrono.h b/packages/seacas/libraries/ioss/src/fmt/chrono.h
index 9ff8ad754db7..8d23eac0484b 100644
--- a/packages/seacas/libraries/ioss/src/fmt/chrono.h
+++ b/packages/seacas/libraries/ioss/src/fmt/chrono.h
@@ -18,11 +18,11 @@
 
 // enable safe chrono durations, unless explicitly disabled
 #ifndef FMT_SAFE_DURATION_CAST
-#  define FMT_SAFE_DURATION_CAST 1
+#define FMT_SAFE_DURATION_CAST 1
 #endif
 
 #if FMT_SAFE_DURATION_CAST
-#  include "safe-duration-cast.h"
+#include "safe-duration-cast.h"
 #endif
 
 FMT_BEGIN_NAMESPACE
@@ -32,28 +32,32 @@ FMT_BEGIN_NAMESPACE
 #define FMT_NOMACRO
 
 namespace internal {
-inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
-inline null<> localtime_s(...) { return null<>(); }
-inline null<> gmtime_r(...) { return null<>(); }
-inline null<> gmtime_s(...) { return null<>(); }
-}  // namespace internal
+  inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
+  inline null<>             localtime_s(...) { return null<>(); }
+  inline null<>             gmtime_r(...) { return null<>(); }
+  inline null<>             gmtime_s(...) { return null<>(); }
+} // namespace internal
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time) {
-  struct dispatcher {
+inline std::tm localtime(std::time_t time)
+{
+  struct dispatcher
+  {
     std::time_t time_;
-    std::tm tm_;
+    std::tm     tm_;
 
     dispatcher(std::time_t t) : time_(t) {}
 
-    bool run() {
+    bool run()
+    {
       using namespace fmt::internal;
       return handle(localtime_r(&time_, &tm_));
     }
 
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    bool handle(std::tm *tm) { return tm != nullptr; }
 
-    bool handle(internal::null<>) {
+    bool handle(internal::null<>)
+    {
       using namespace fmt::internal;
       return fallback(localtime_s(&tm_, &time_));
     }
@@ -61,36 +65,43 @@ inline std::tm localtime(std::time_t time) {
     bool fallback(int res) { return res == 0; }
 
 #if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
+    bool fallback(internal::null<>)
+    {
       using namespace fmt::internal;
-      std::tm* tm = std::localtime(&time_);
-      if (tm) tm_ = *tm;
+      std::tm *tm = std::localtime(&time_);
+      if (tm)
+        tm_ = *tm;
       return tm != nullptr;
     }
 #endif
   };
   dispatcher lt(time);
   // Too big time values may be unsupported.
-  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
+  if (!lt.run())
+    FMT_THROW(format_error("time_t value out of range"));
   return lt.tm_;
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time) {
-  struct dispatcher {
+inline std::tm gmtime(std::time_t time)
+{
+  struct dispatcher
+  {
     std::time_t time_;
-    std::tm tm_;
+    std::tm     tm_;
 
     dispatcher(std::time_t t) : time_(t) {}
 
-    bool run() {
+    bool run()
+    {
       using namespace fmt::internal;
       return handle(gmtime_r(&time_, &tm_));
     }
 
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    bool handle(std::tm *tm) { return tm != nullptr; }
 
-    bool handle(internal::null<>) {
+    bool handle(internal::null<>)
+    {
       using namespace fmt::internal;
       return fallback(gmtime_s(&tm_, &time_));
     }
@@ -98,38 +109,45 @@ inline std::tm gmtime(std::time_t time) {
     bool fallback(int res) { return res == 0; }
 
 #if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
-      std::tm* tm = std::gmtime(&time_);
-      if (tm) tm_ = *tm;
+    bool fallback(internal::null<>)
+    {
+      std::tm *tm = std::gmtime(&time_);
+      if (tm)
+        tm_ = *tm;
       return tm != nullptr;
     }
 #endif
   };
   dispatcher gt(time);
   // Too big time values may be unsupported.
-  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
+  if (!gt.run())
+    FMT_THROW(format_error("time_t value out of range"));
   return gt.tm_;
 }
 
 namespace internal {
-inline std::size_t strftime(char* str, std::size_t count, const char* format,
-                            const std::tm* time) {
-  return std::strftime(str, count, format, time);
-}
+  inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
+  {
+    return std::strftime(str, count, format, time);
+  }
 
-inline std::size_t strftime(wchar_t* str, std::size_t count,
-                            const wchar_t* format, const std::tm* time) {
-  return std::wcsftime(str, count, format, time);
-}
-}  // namespace internal
+  inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format,
+                              const std::tm *time)
+  {
+    return std::wcsftime(str, count, format, time);
+  }
+} // namespace internal
 
-template <typename Char> struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+template <typename Char> struct formatter<std::tm, Char>
+{
+  template <typename ParseContext> auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     auto it = ctx.begin();
-    if (it != ctx.end() && *it == ':') ++it;
+    if (it != ctx.end() && *it == ':')
+      ++it;
     auto end = it;
-    while (end != ctx.end() && *end != '}') ++end;
+    while (end != ctx.end() && *end != '}')
+      ++end;
     tm_format.reserve(internal::to_unsigned(end - it + 1));
     tm_format.append(it, end);
     tm_format.push_back('\0');
@@ -137,13 +155,13 @@ template <typename Char> struct formatter<std::tm, Char> {
   }
 
   template <typename FormatContext>
-  auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
+  {
     basic_memory_buffer<Char> buf;
-    std::size_t start = buf.size();
+    std::size_t               start = buf.size();
     for (;;) {
-      std::size_t size = buf.capacity() - start;
-      std::size_t count =
-          internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      std::size_t size  = buf.capacity() - start;
+      std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
       if (count != 0) {
         buf.resize(start + count);
         break;
@@ -165,617 +183,589 @@ template <typename Char> struct formatter<std::tm, Char> {
 };
 
 namespace internal {
-template <typename Period> FMT_CONSTEXPR const char* get_units() {
-  return nullptr;
-}
-template <> FMT_CONSTEXPR const char* get_units<std::atto>() { return "as"; }
-template <> FMT_CONSTEXPR const char* get_units<std::femto>() { return "fs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::pico>() { return "ps"; }
-template <> FMT_CONSTEXPR const char* get_units<std::nano>() { return "ns"; }
-template <> FMT_CONSTEXPR const char* get_units<std::micro>() { return "µs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::milli>() { return "ms"; }
-template <> FMT_CONSTEXPR const char* get_units<std::centi>() { return "cs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::deci>() { return "ds"; }
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<1>>() { return "s"; }
-template <> FMT_CONSTEXPR const char* get_units<std::deca>() { return "das"; }
-template <> FMT_CONSTEXPR const char* get_units<std::hecto>() { return "hs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::kilo>() { return "ks"; }
-template <> FMT_CONSTEXPR const char* get_units<std::mega>() { return "Ms"; }
-template <> FMT_CONSTEXPR const char* get_units<std::giga>() { return "Gs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::tera>() { return "Ts"; }
-template <> FMT_CONSTEXPR const char* get_units<std::peta>() { return "Ps"; }
-template <> FMT_CONSTEXPR const char* get_units<std::exa>() { return "Es"; }
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<60>>() {
-  return "m";
-}
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<3600>>() {
-  return "h";
-}
-
-enum class numeric_system {
-  standard,
-  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
-  alternative
-};
+  template <typename Period> FMT_CONSTEXPR const char *get_units() { return nullptr; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::atto>() { return "as"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::femto>() { return "fs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::pico>() { return "ps"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::nano>() { return "ns"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::micro>() { return "µs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::milli>() { return "ms"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::centi>() { return "cs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::deci>() { return "ds"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::ratio<1>>() { return "s"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::deca>() { return "das"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::hecto>() { return "hs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::kilo>() { return "ks"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::mega>() { return "Ms"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::giga>() { return "Gs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::tera>() { return "Ts"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::peta>() { return "Ps"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::exa>() { return "Es"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::ratio<60>>() { return "m"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::ratio<3600>>() { return "h"; }
+
+  enum class numeric_system {
+    standard,
+    // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
+    alternative
+  };
 
-// Parses a put_time-like format string and invokes handler actions.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
-                                              const Char* end,
-                                              Handler&& handler) {
-  auto ptr = begin;
-  while (ptr != end) {
-    auto c = *ptr;
-    if (c == '}') break;
-    if (c != '%') {
-      ++ptr;
-      continue;
-    }
-    if (begin != ptr) handler.on_text(begin, ptr);
-    ++ptr;  // consume '%'
-    if (ptr == end) FMT_THROW(format_error("invalid format"));
-    c = *ptr++;
-    switch (c) {
-    case '%':
-      handler.on_text(ptr - 1, ptr);
-      break;
-    case 'n': {
-      const char newline[] = "\n";
-      handler.on_text(newline, newline + 1);
-      break;
-    }
-    case 't': {
-      const char tab[] = "\t";
-      handler.on_text(tab, tab + 1);
-      break;
-    }
-    // Day of the week:
-    case 'a':
-      handler.on_abbr_weekday();
-      break;
-    case 'A':
-      handler.on_full_weekday();
-      break;
-    case 'w':
-      handler.on_dec0_weekday(numeric_system::standard);
-      break;
-    case 'u':
-      handler.on_dec1_weekday(numeric_system::standard);
-      break;
-    // Month:
-    case 'b':
-      handler.on_abbr_month();
-      break;
-    case 'B':
-      handler.on_full_month();
-      break;
-    // Hour, minute, second:
-    case 'H':
-      handler.on_24_hour(numeric_system::standard);
-      break;
-    case 'I':
-      handler.on_12_hour(numeric_system::standard);
-      break;
-    case 'M':
-      handler.on_minute(numeric_system::standard);
-      break;
-    case 'S':
-      handler.on_second(numeric_system::standard);
-      break;
-    // Other:
-    case 'c':
-      handler.on_datetime(numeric_system::standard);
-      break;
-    case 'x':
-      handler.on_loc_date(numeric_system::standard);
-      break;
-    case 'X':
-      handler.on_loc_time(numeric_system::standard);
-      break;
-    case 'D':
-      handler.on_us_date();
-      break;
-    case 'F':
-      handler.on_iso_date();
-      break;
-    case 'r':
-      handler.on_12_hour_time();
-      break;
-    case 'R':
-      handler.on_24_hour_time();
-      break;
-    case 'T':
-      handler.on_iso_time();
-      break;
-    case 'p':
-      handler.on_am_pm();
-      break;
-    case 'Q':
-      handler.on_duration_value();
-      break;
-    case 'q':
-      handler.on_duration_unit();
-      break;
-    case 'z':
-      handler.on_utc_offset();
-      break;
-    case 'Z':
-      handler.on_tz_name();
-      break;
-    // Alternative representation:
-    case 'E': {
-      if (ptr == end) FMT_THROW(format_error("invalid format"));
-      c = *ptr++;
-      switch (c) {
-      case 'c':
-        handler.on_datetime(numeric_system::alternative);
+  // Parses a put_time-like format string and invokes handler actions.
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_chrono_format(const Char *begin, const Char *end,
+                                                Handler &&handler)
+  {
+    auto ptr = begin;
+    while (ptr != end) {
+      auto c = *ptr;
+      if (c == '}')
         break;
-      case 'x':
-        handler.on_loc_date(numeric_system::alternative);
-        break;
-      case 'X':
-        handler.on_loc_time(numeric_system::alternative);
-        break;
-      default:
-        FMT_THROW(format_error("invalid format"));
+      if (c != '%') {
+        ++ptr;
+        continue;
       }
-      break;
-    }
-    case 'O':
-      if (ptr == end) FMT_THROW(format_error("invalid format"));
+      if (begin != ptr)
+        handler.on_text(begin, ptr);
+      ++ptr; // consume '%'
+      if (ptr == end)
+        FMT_THROW(format_error("invalid format"));
       c = *ptr++;
       switch (c) {
-      case 'w':
-        handler.on_dec0_weekday(numeric_system::alternative);
-        break;
-      case 'u':
-        handler.on_dec1_weekday(numeric_system::alternative);
-        break;
-      case 'H':
-        handler.on_24_hour(numeric_system::alternative);
+      case '%': handler.on_text(ptr - 1, ptr); break;
+      case 'n': {
+        const char newline[] = "\n";
+        handler.on_text(newline, newline + 1);
         break;
-      case 'I':
-        handler.on_12_hour(numeric_system::alternative);
+      }
+      case 't': {
+        const char tab[] = "\t";
+        handler.on_text(tab, tab + 1);
         break;
-      case 'M':
-        handler.on_minute(numeric_system::alternative);
+      }
+      // Day of the week:
+      case 'a': handler.on_abbr_weekday(); break;
+      case 'A': handler.on_full_weekday(); break;
+      case 'w': handler.on_dec0_weekday(numeric_system::standard); break;
+      case 'u': handler.on_dec1_weekday(numeric_system::standard); break;
+      // Month:
+      case 'b': handler.on_abbr_month(); break;
+      case 'B': handler.on_full_month(); break;
+      // Hour, minute, second:
+      case 'H': handler.on_24_hour(numeric_system::standard); break;
+      case 'I': handler.on_12_hour(numeric_system::standard); break;
+      case 'M': handler.on_minute(numeric_system::standard); break;
+      case 'S': handler.on_second(numeric_system::standard); break;
+      // Other:
+      case 'c': handler.on_datetime(numeric_system::standard); break;
+      case 'x': handler.on_loc_date(numeric_system::standard); break;
+      case 'X': handler.on_loc_time(numeric_system::standard); break;
+      case 'D': handler.on_us_date(); break;
+      case 'F': handler.on_iso_date(); break;
+      case 'r': handler.on_12_hour_time(); break;
+      case 'R': handler.on_24_hour_time(); break;
+      case 'T': handler.on_iso_time(); break;
+      case 'p': handler.on_am_pm(); break;
+      case 'Q': handler.on_duration_value(); break;
+      case 'q': handler.on_duration_unit(); break;
+      case 'z': handler.on_utc_offset(); break;
+      case 'Z': handler.on_tz_name(); break;
+      // Alternative representation:
+      case 'E': {
+        if (ptr == end)
+          FMT_THROW(format_error("invalid format"));
+        c = *ptr++;
+        switch (c) {
+        case 'c': handler.on_datetime(numeric_system::alternative); break;
+        case 'x': handler.on_loc_date(numeric_system::alternative); break;
+        case 'X': handler.on_loc_time(numeric_system::alternative); break;
+        default: FMT_THROW(format_error("invalid format"));
+        }
         break;
-      case 'S':
-        handler.on_second(numeric_system::alternative);
+      }
+      case 'O':
+        if (ptr == end)
+          FMT_THROW(format_error("invalid format"));
+        c = *ptr++;
+        switch (c) {
+        case 'w': handler.on_dec0_weekday(numeric_system::alternative); break;
+        case 'u': handler.on_dec1_weekday(numeric_system::alternative); break;
+        case 'H': handler.on_24_hour(numeric_system::alternative); break;
+        case 'I': handler.on_12_hour(numeric_system::alternative); break;
+        case 'M': handler.on_minute(numeric_system::alternative); break;
+        case 'S': handler.on_second(numeric_system::alternative); break;
+        default: FMT_THROW(format_error("invalid format"));
+        }
         break;
-      default:
-        FMT_THROW(format_error("invalid format"));
+      default: FMT_THROW(format_error("invalid format"));
       }
-      break;
-    default:
-      FMT_THROW(format_error("invalid format"));
+      begin = ptr;
     }
-    begin = ptr;
+    if (begin != ptr)
+      handler.on_text(begin, ptr);
+    return ptr;
   }
-  if (begin != ptr) handler.on_text(begin, ptr);
-  return ptr;
-}
 
-struct chrono_format_checker {
-  FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
-
-  template <typename Char> void on_text(const Char*, const Char*) {}
-  FMT_NORETURN void on_abbr_weekday() { report_no_date(); }
-  FMT_NORETURN void on_full_weekday() { report_no_date(); }
-  FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_abbr_month() { report_no_date(); }
-  FMT_NORETURN void on_full_month() { report_no_date(); }
-  void on_24_hour(numeric_system) {}
-  void on_12_hour(numeric_system) {}
-  void on_minute(numeric_system) {}
-  void on_second(numeric_system) {}
-  FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_us_date() { report_no_date(); }
-  FMT_NORETURN void on_iso_date() { report_no_date(); }
-  void on_12_hour_time() {}
-  void on_24_hour_time() {}
-  void on_iso_time() {}
-  void on_am_pm() {}
-  void on_duration_value() {}
-  void on_duration_unit() {}
-  FMT_NORETURN void on_utc_offset() { report_no_date(); }
-  FMT_NORETURN void on_tz_name() { report_no_date(); }
-};
+  struct chrono_format_checker
+  {
+    FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
+
+    template <typename Char> void on_text(const Char *, const Char *) {}
+    FMT_NORETURN void             on_abbr_weekday() { report_no_date(); }
+    FMT_NORETURN void             on_full_weekday() { report_no_date(); }
+    FMT_NORETURN void             on_dec0_weekday(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_dec1_weekday(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_abbr_month() { report_no_date(); }
+    FMT_NORETURN void             on_full_month() { report_no_date(); }
+    void                          on_24_hour(numeric_system) {}
+    void                          on_12_hour(numeric_system) {}
+    void                          on_minute(numeric_system) {}
+    void                          on_second(numeric_system) {}
+    FMT_NORETURN void             on_datetime(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_loc_date(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_loc_time(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_us_date() { report_no_date(); }
+    FMT_NORETURN void             on_iso_date() { report_no_date(); }
+    void                          on_12_hour_time() {}
+    void                          on_24_hour_time() {}
+    void                          on_iso_time() {}
+    void                          on_am_pm() {}
+    void                          on_duration_value() {}
+    void                          on_duration_unit() {}
+    FMT_NORETURN void             on_utc_offset() { report_no_date(); }
+    FMT_NORETURN void             on_tz_name() { report_no_date(); }
+  };
 
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline bool isnan(T) {
-  return false;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isnan(T value) {
-  return std::isnan(value);
-}
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline bool isnan(T)
+  {
+    return false;
+  }
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> inline bool isnan(T value)
+  {
+    return std::isnan(value);
+  }
 
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline bool isfinite(T) {
-  return true;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isfinite(T value) {
-  return std::isfinite(value);
-}
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline bool isfinite(T)
+  {
+    return true;
+  }
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  inline bool isfinite(T value)
+  {
+    return std::isfinite(value);
+  }
 
-// Convers value to int and checks that it's in the range [0, upper).
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline int to_nonnegative_int(T value, int upper) {
-  FMT_ASSERT(value >= 0 && value <= upper, "invalid value");
-  (void)upper;
-  return static_cast<int>(value);
-}
-template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-inline int to_nonnegative_int(T value, int upper) {
-  FMT_ASSERT(
-      std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
-      "invalid value");
-  (void)upper;
-  return static_cast<int>(value);
-}
+  // Converts value to int and checks that it's in the range [0, upper).
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  inline int to_nonnegative_int(T value, int upper)
+  {
+    FMT_ASSERT(value >= 0 && value <= upper, "invalid value");
+    (void)upper;
+    return static_cast<int>(value);
+  }
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  inline int to_nonnegative_int(T value, int upper)
+  {
+    FMT_ASSERT(std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
+               "invalid value");
+    (void)upper;
+    return static_cast<int>(value);
+  }
 
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline T mod(T x, int y) {
-  return x % y;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline T mod(T x, int y) {
-  return std::fmod(x, static_cast<T>(y));
-}
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline T mod(T x, int y)
+  {
+    return x % y;
+  }
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> inline T mod(T x, int y)
+  {
+    return std::fmod(x, static_cast<T>(y));
+  }
 
-// If T is an integral type, maps T to its unsigned counterpart, otherwise
-// leaves it unchanged (unlike std::make_unsigned).
-template <typename T, bool INTEGRAL = std::is_integral<T>::value>
-struct make_unsigned_or_unchanged {
-  using type = T;
-};
+  // If T is an integral type, maps T to its unsigned counterpart, otherwise
+  // leaves it unchanged (unlike std::make_unsigned).
+  template <typename T, bool INTEGRAL = std::is_integral<T>::value>
+  struct make_unsigned_or_unchanged
+  {
+    using type = T;
+  };
 
-template <typename T> struct make_unsigned_or_unchanged<T, true> {
-  using type = typename std::make_unsigned<T>::type;
-};
+  template <typename T> struct make_unsigned_or_unchanged<T, true>
+  {
+    using type = typename std::make_unsigned<T>::type;
+  };
 
 #if FMT_SAFE_DURATION_CAST
-// throwing version of safe_duration_cast
-template <typename To, typename FromRep, typename FromPeriod>
-To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) {
-  int ec;
-  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
-  if (ec) FMT_THROW(format_error("cannot format duration"));
-  return to;
-}
+  // throwing version of safe_duration_cast
+  template <typename To, typename FromRep, typename FromPeriod>
+  To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from)
+  {
+    int ec;
+    To  to = safe_duration_cast::safe_duration_cast<To>(from, ec);
+    if (ec)
+      FMT_THROW(format_error("cannot format duration"));
+    return to;
+  }
 #endif
 
-template <typename Rep, typename Period,
-          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
-inline std::chrono::duration<Rep, std::milli> get_milliseconds(
-    std::chrono::duration<Rep, Period> d) {
-  // this may overflow and/or the result may not fit in the
-  // target type.
+  template <typename Rep, typename Period, FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+  inline std::chrono::duration<Rep, std::milli>
+  get_milliseconds(std::chrono::duration<Rep, Period> d)
+  {
+    // this may overflow and/or the result may not fit in the
+    // target type.
 #if FMT_SAFE_DURATION_CAST
-  using CommonSecondsType =
-      typename std::common_type<decltype(d), std::chrono::seconds>::type;
-  const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
-  const auto d_as_whole_seconds =
-      fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
-  // this conversion should be nonproblematic
-  const auto diff = d_as_common - d_as_whole_seconds;
-  const auto ms =
-      fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
-  return ms;
+    using CommonSecondsType = typename std::common_type<decltype(d), std::chrono::seconds>::type;
+    const auto d_as_common  = fmt_safe_duration_cast<CommonSecondsType>(d);
+    const auto d_as_whole_seconds = fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
+    // this conversion should be nonproblematic
+    const auto diff = d_as_common - d_as_whole_seconds;
+    const auto ms   = fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+    return ms;
 #else
-  auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
-  return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
+    auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
+    return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
 #endif
-}
+  }
 
-template <typename Rep, typename Period,
-          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
-inline std::chrono::duration<Rep, std::milli> get_milliseconds(
-    std::chrono::duration<Rep, Period> d) {
-  using common_type = typename std::common_type<Rep, std::intmax_t>::type;
-  auto ms = mod(d.count() * static_cast<common_type>(Period::num) /
-                    static_cast<common_type>(Period::den) * 1000,
-                1000);
-  return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
-}
+  template <typename Rep, typename Period, FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
+  inline std::chrono::duration<Rep, std::milli>
+  get_milliseconds(std::chrono::duration<Rep, Period> d)
+  {
+    using common_type = typename std::common_type<Rep, std::intmax_t>::type;
+    auto ms           = mod(d.count() * static_cast<common_type>(Period::num) /
+                      static_cast<common_type>(Period::den) * 1000,
+                  1000);
+    return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
+  }
 
-template <typename Rep, typename OutputIt>
-OutputIt format_chrono_duration_value(OutputIt out, Rep val, int precision) {
-  if (precision >= 0) return format_to(out, "{:.{}f}", val, precision);
-  return format_to(out, std::is_floating_point<Rep>::value ? "{:g}" : "{}",
-                   val);
-}
+  template <typename Rep, typename OutputIt>
+  OutputIt format_chrono_duration_value(OutputIt out, Rep val, int precision)
+  {
+    if (precision >= 0)
+      return format_to(out, "{:.{}f}", val, precision);
+    return format_to(out, std::is_floating_point<Rep>::value ? "{:g}" : "{}", val);
+  }
 
-template <typename Period, typename OutputIt>
-static OutputIt format_chrono_duration_unit(OutputIt out) {
-  if (const char* unit = get_units<Period>()) return format_to(out, "{}", unit);
-  if (Period::den == 1) return format_to(out, "[{}]s", Period::num);
-  return format_to(out, "[{}/{}]s", Period::num, Period::den);
-}
+  template <typename Period, typename OutputIt>
+  static OutputIt format_chrono_duration_unit(OutputIt out)
+  {
+    if (const char *unit = get_units<Period>())
+      return format_to(out, "{}", unit);
+    if (Period::den == 1)
+      return format_to(out, "[{}]s", Period::num);
+    return format_to(out, "[{}/{}]s", Period::num, Period::den);
+  }
 
-template <typename FormatContext, typename OutputIt, typename Rep,
-          typename Period>
-struct chrono_formatter {
-  FormatContext& context;
-  OutputIt out;
-  int precision;
-  // rep is unsigned to avoid overflow.
-  using rep =
-      conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
-                    unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
-  rep val;
-  using seconds = std::chrono::duration<rep>;
-  seconds s;
-  using milliseconds = std::chrono::duration<rep, std::milli>;
-  bool negative;
-
-  using char_type = typename FormatContext::char_type;
-
-  explicit chrono_formatter(FormatContext& ctx, OutputIt o,
-                            std::chrono::duration<Rep, Period> d)
-      : context(ctx), out(o), val(d.count()), negative(false) {
-    if (d.count() < 0) {
-      val = 0 - val;
-      negative = true;
-    }
+  template <typename FormatContext, typename OutputIt, typename Rep, typename Period>
+  struct chrono_formatter
+  {
+    FormatContext &context;
+    OutputIt       out;
+    int            precision;
+    // rep is unsigned to avoid overflow.
+    using rep = conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int), unsigned,
+                              typename make_unsigned_or_unchanged<Rep>::type>;
+    rep val;
+    using seconds = std::chrono::duration<rep>;
+    seconds s;
+    using milliseconds = std::chrono::duration<rep, std::milli>;
+    bool negative;
+
+    using char_type = typename FormatContext::char_type;
+
+    explicit chrono_formatter(FormatContext &ctx, OutputIt o, std::chrono::duration<Rep, Period> d)
+        : context(ctx), out(o), val(d.count()), negative(false)
+    {
+      if (d.count() < 0) {
+        val      = 0 - val;
+        negative = true;
+      }
 
-    // this may overflow and/or the result may not fit in the
-    // target type.
+      // this may overflow and/or the result may not fit in the
+      // target type.
 #if FMT_SAFE_DURATION_CAST
-    // might need checked conversion (rep!=Rep)
-    auto tmpval = std::chrono::duration<rep, Period>(val);
-    s = fmt_safe_duration_cast<seconds>(tmpval);
+      // might need checked conversion (rep!=Rep)
+      auto tmpval = std::chrono::duration<rep, Period>(val);
+      s           = fmt_safe_duration_cast<seconds>(tmpval);
 #else
-    s = std::chrono::duration_cast<seconds>(
-        std::chrono::duration<rep, Period>(val));
+      s = std::chrono::duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
 #endif
-  }
-
-  // returns true if nan or inf, writes to out.
-  bool handle_nan_inf() {
-    if (isfinite(val)) {
-      return false;
     }
-    if (isnan(val)) {
-      write_nan();
+
+    // returns true if nan or inf, writes to out.
+    bool handle_nan_inf()
+    {
+      if (isfinite(val)) {
+        return false;
+      }
+      if (isnan(val)) {
+        write_nan();
+        return true;
+      }
+      // must be +-inf
+      if (val > 0) {
+        write_pinf();
+      }
+      else {
+        write_ninf();
+      }
       return true;
     }
-    // must be +-inf
-    if (val > 0) {
-      write_pinf();
-    } else {
-      write_ninf();
-    }
-    return true;
-  }
 
-  Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
+    Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
 
-  Rep hour12() const {
-    Rep my_hour = static_cast<Rep>(mod((s.count() / 3600), 12));
-    return my_hour <= 0 ? 12 : my_hour;
-  }
-
-  Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
-  Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
+    Rep hour12() const
+    {
+      Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
+      return hour <= 0 ? 12 : hour;
+    }
 
-  std::tm time() const {
-    auto my_time = std::tm();
-    my_time.tm_hour = to_nonnegative_int(hour(), 24);
-    my_time.tm_min = to_nonnegative_int(minute(), 60);
-    my_time.tm_sec = to_nonnegative_int(second(), 60);
-    return my_time;
-  }
+    Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
+    Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
 
-  void write_sign() {
-    if (negative) {
-      *out++ = '-';
-      negative = false;
+    std::tm time() const
+    {
+      auto time    = std::tm();
+      time.tm_hour = to_nonnegative_int(hour(), 24);
+      time.tm_min  = to_nonnegative_int(minute(), 60);
+      time.tm_sec  = to_nonnegative_int(second(), 60);
+      return time;
     }
-  }
 
-  void write(Rep value, int width) {
-    write_sign();
-    if (isnan(value)) return write_nan();
-    uint32_or_64_t<int> n = to_unsigned(
-        to_nonnegative_int(value, (std::numeric_limits<int>::max)()));
-    int num_digits = internal::count_digits(n);
-    if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
-    out = format_decimal<char_type>(out, n, num_digits);
-  }
+    void write_sign()
+    {
+      if (negative) {
+        *out++   = '-';
+        negative = false;
+      }
+    }
 
-  void write_nan() { std::copy_n("nan", 3, out); }
-  void write_pinf() { std::copy_n("inf", 3, out); }
-  void write_ninf() { std::copy_n("-inf", 4, out); }
-
-  void format_localized(const tm& my_time, const char* format) {
-    if (isnan(val)) return write_nan();
-    auto locale = context.locale().template get<std::locale>();
-    auto& facet = std::use_facet<std::time_put<char_type>>(locale);
-    std::basic_ostringstream<char_type> os;
-    os.imbue(locale);
-    facet.put(os, os, ' ', &my_time, format, format + std::strlen(format));
-    auto str = os.str();
-    std::copy(str.begin(), str.end(), out);
-  }
+    void write(Rep value, int width)
+    {
+      write_sign();
+      if (isnan(value))
+        return write_nan();
+      uint32_or_64_or_128_t<int> n = to_unsigned(to_nonnegative_int(value, max_value<int>()));
+      int                        num_digits = internal::count_digits(n);
+      if (width > num_digits)
+        out = std::fill_n(out, width - num_digits, '0');
+      out = format_decimal<char_type>(out, n, num_digits);
+    }
 
-  void on_text(const char_type* begin, const char_type* end) {
-    std::copy(begin, end, out);
-  }
+    void write_nan() { std::copy_n("nan", 3, out); }
+    void write_pinf() { std::copy_n("inf", 3, out); }
+    void write_ninf() { std::copy_n("-inf", 4, out); }
+
+    void format_localized(const tm &time, const char *format)
+    {
+      if (isnan(val))
+        return write_nan();
+      auto                                locale = context.locale().template get<std::locale>();
+      auto &                              facet  = std::use_facet<std::time_put<char_type>>(locale);
+      std::basic_ostringstream<char_type> os;
+      os.imbue(locale);
+      facet.put(os, os, ' ', &time, format, format + std::strlen(format));
+      auto str = os.str();
+      std::copy(str.begin(), str.end(), out);
+    }
 
-  // These are not implemented because durations don't have date information.
-  void on_abbr_weekday() {}
-  void on_full_weekday() {}
-  void on_dec0_weekday(numeric_system) {}
-  void on_dec1_weekday(numeric_system) {}
-  void on_abbr_month() {}
-  void on_full_month() {}
-  void on_datetime(numeric_system) {}
-  void on_loc_date(numeric_system) {}
-  void on_loc_time(numeric_system) {}
-  void on_us_date() {}
-  void on_iso_date() {}
-  void on_utc_offset() {}
-  void on_tz_name() {}
-
-  void on_24_hour(numeric_system ns) {
-    if (handle_nan_inf()) return;
-
-    if (ns == numeric_system::standard) return write(hour(), 2);
-    auto my_time = tm();
-    my_time.tm_hour = to_nonnegative_int(hour(), 24);
-    format_localized(my_time, "%OH");
-  }
+    void on_text(const char_type *begin, const char_type *end) { std::copy(begin, end, out); }
+
+    // These are not implemented because durations don't have date information.
+    void on_abbr_weekday() {}
+    void on_full_weekday() {}
+    void on_dec0_weekday(numeric_system) {}
+    void on_dec1_weekday(numeric_system) {}
+    void on_abbr_month() {}
+    void on_full_month() {}
+    void on_datetime(numeric_system) {}
+    void on_loc_date(numeric_system) {}
+    void on_loc_time(numeric_system) {}
+    void on_us_date() {}
+    void on_iso_date() {}
+    void on_utc_offset() {}
+    void on_tz_name() {}
+
+    void on_24_hour(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
+
+      if (ns == numeric_system::standard)
+        return write(hour(), 2);
+      auto time    = tm();
+      time.tm_hour = to_nonnegative_int(hour(), 24);
+      format_localized(time, "%OH");
+    }
 
-  void on_12_hour(numeric_system ns) {
-    if (handle_nan_inf()) return;
+    void on_12_hour(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
 
-    if (ns == numeric_system::standard) return write(hour12(), 2);
-    auto my_time = tm();
-    my_time.tm_hour = to_nonnegative_int(hour12(), 12);
-    format_localized(my_time, "%OI");
-  }
+      if (ns == numeric_system::standard)
+        return write(hour12(), 2);
+      auto time    = tm();
+      time.tm_hour = to_nonnegative_int(hour12(), 12);
+      format_localized(time, "%OI");
+    }
 
-  void on_minute(numeric_system ns) {
-    if (handle_nan_inf()) return;
+    void on_minute(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
 
-    if (ns == numeric_system::standard) return write(minute(), 2);
-    auto my_time = tm();
-    my_time.tm_min = to_nonnegative_int(minute(), 60);
-    format_localized(my_time, "%OM");
-  }
+      if (ns == numeric_system::standard)
+        return write(minute(), 2);
+      auto time   = tm();
+      time.tm_min = to_nonnegative_int(minute(), 60);
+      format_localized(time, "%OM");
+    }
 
-  void on_second(numeric_system ns) {
-    if (handle_nan_inf()) return;
+    void on_second(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
 
-    if (ns == numeric_system::standard) {
-      write(second(), 2);
+      if (ns == numeric_system::standard) {
+        write(second(), 2);
 #if FMT_SAFE_DURATION_CAST
-      // convert rep->Rep
-      using duration_rep = std::chrono::duration<rep, Period>;
-      using duration_Rep = std::chrono::duration<Rep, Period>;
-      auto tmpval = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
+        // convert rep->Rep
+        using duration_rep = std::chrono::duration<rep, Period>;
+        using duration_Rep = std::chrono::duration<Rep, Period>;
+        auto tmpval        = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
 #else
-      auto tmpval = std::chrono::duration<Rep, Period>(val);
+        auto tmpval = std::chrono::duration<Rep, Period>(val);
 #endif
-      auto ms = get_milliseconds(tmpval);
-      if (ms != std::chrono::milliseconds(0)) {
-        *out++ = '.';
-        write(ms.count(), 3);
+        auto ms = get_milliseconds(tmpval);
+        if (ms != std::chrono::milliseconds(0)) {
+          *out++ = '.';
+          write(ms.count(), 3);
+        }
+        return;
       }
-      return;
+      auto time   = tm();
+      time.tm_sec = to_nonnegative_int(second(), 60);
+      format_localized(time, "%OS");
     }
-    auto my_time = tm();
-    my_time.tm_sec = to_nonnegative_int(second(), 60);
-    format_localized(my_time, "%OS");
-  }
 
-  void on_12_hour_time() {
-    if (handle_nan_inf()) return;
+    void on_12_hour_time()
+    {
+      if (handle_nan_inf())
+        return;
 
-    format_localized(time(), "%r");
-  }
+      format_localized(time(), "%r");
+    }
 
-  void on_24_hour_time() {
-    if (handle_nan_inf()) {
+    void on_24_hour_time()
+    {
+      if (handle_nan_inf()) {
+        *out++ = ':';
+        handle_nan_inf();
+        return;
+      }
+
+      write(hour(), 2);
       *out++ = ':';
-      handle_nan_inf();
-      return;
+      write(minute(), 2);
     }
 
-    write(hour(), 2);
-    *out++ = ':';
-    write(minute(), 2);
-  }
-
-  void on_iso_time() {
-    on_24_hour_time();
-    *out++ = ':';
-    if (handle_nan_inf()) return;
-    write(second(), 2);
-  }
+    void on_iso_time()
+    {
+      on_24_hour_time();
+      *out++ = ':';
+      if (handle_nan_inf())
+        return;
+      write(second(), 2);
+    }
 
-  void on_am_pm() {
-    if (handle_nan_inf()) return;
-    format_localized(time(), "%p");
-  }
+    void on_am_pm()
+    {
+      if (handle_nan_inf())
+        return;
+      format_localized(time(), "%p");
+    }
 
-  void on_duration_value() {
-    if (handle_nan_inf()) return;
-    write_sign();
-    out = format_chrono_duration_value(out, val, precision);
-  }
+    void on_duration_value()
+    {
+      if (handle_nan_inf())
+        return;
+      write_sign();
+      out = format_chrono_duration_value(out, val, precision);
+    }
 
-  void on_duration_unit() { out = format_chrono_duration_unit<Period>(out); }
-};
-}  // namespace internal
+    void on_duration_unit() { out = format_chrono_duration_unit<Period>(out); }
+  };
+} // namespace internal
 
 template <typename Rep, typename Period, typename Char>
-struct formatter<std::chrono::duration<Rep, Period>, Char> {
- private:
+struct formatter<std::chrono::duration<Rep, Period>, Char>
+{
+private:
   basic_format_specs<Char> specs;
-  int precision;
+  int                      precision;
   using arg_ref_type = internal::arg_ref<Char>;
-  arg_ref_type width_ref;
-  arg_ref_type precision_ref;
+  arg_ref_type                    width_ref;
+  arg_ref_type                    precision_ref;
   mutable basic_string_view<Char> format_str;
   using duration = std::chrono::duration<Rep, Period>;
 
-  struct spec_handler {
-    formatter& f;
-    basic_parse_context<Char>& context;
-    basic_string_view<Char> format_str;
+  struct spec_handler
+  {
+    formatter &                f;
+    basic_parse_context<Char> &context;
+    basic_string_view<Char>    format_str;
 
-    template <typename Id> FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
+    template <typename Id> FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id)
+    {
       context.check_arg_id(arg_id);
       return arg_ref_type(arg_id);
     }
 
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id) {
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id)
+    {
       context.check_arg_id(arg_id);
-      const auto str_val = internal::string_view_metadata(format_str, arg_id);
-      return arg_ref_type(str_val);
+      return arg_ref_type(arg_id);
     }
 
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id) {
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id)
+    {
       return arg_ref_type(context.next_arg_id());
     }
 
-    void on_error(const char* msg) { FMT_THROW(format_error(msg)); }
+    void on_error(const char *msg) { FMT_THROW(format_error(msg)); }
     void on_fill(Char fill) { f.specs.fill[0] = fill; }
     void on_align(align_t align) { f.specs.align = align; }
     void on_width(unsigned width) { f.specs.width = width; }
-    void on_precision(unsigned precision) { f.precision = precision; }
+    void on_precision(unsigned _precision) { f.precision = _precision; }
     void end_precision() {}
 
-    template <typename Id> void on_dynamic_width(Id arg_id) {
-      f.width_ref = make_arg_ref(arg_id);
-    }
+    template <typename Id> void on_dynamic_width(Id arg_id) { f.width_ref = make_arg_ref(arg_id); }
 
-    template <typename Id> void on_dynamic_precision(Id arg_id) {
+    template <typename Id> void on_dynamic_precision(Id arg_id)
+    {
       f.precision_ref = make_arg_ref(arg_id);
     }
   };
 
   using iterator = typename basic_parse_context<Char>::iterator;
-  struct parse_range {
+  struct parse_range
+  {
     iterator begin;
     iterator end;
   };
 
-  FMT_CONSTEXPR parse_range do_parse(basic_parse_context<Char>& ctx) {
+  FMT_CONSTEXPR parse_range do_parse(basic_parse_context<Char> &ctx)
+  {
     auto begin = ctx.begin(), end = ctx.end();
-    if (begin == end || *begin == '}') return {begin, begin};
+    if (begin == end || *begin == '}')
+      return {begin, begin};
     spec_handler handler{*this, ctx, format_str};
     begin = internal::parse_align(begin, end, handler);
-    if (begin == end) return {begin, begin};
+    if (begin == end)
+      return {begin, begin};
     begin = internal::parse_width(begin, end, handler);
-    if (begin == end) return {begin, begin};
+    if (begin == end)
+      return {begin, begin};
     if (*begin == '.') {
       if (std::is_floating_point<Rep>::value)
         begin = internal::parse_precision(begin, end, handler);
@@ -786,36 +776,35 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     return {begin, end};
   }
 
- public:
+public:
   formatter() : precision(-1) {}
 
-  FMT_CONSTEXPR auto parse(basic_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(basic_parse_context<Char> &ctx) -> decltype(ctx.begin())
+  {
     auto range = do_parse(ctx);
-    format_str = basic_string_view<Char>(
-        &*range.begin, internal::to_unsigned(range.end - range.begin));
+    format_str =
+        basic_string_view<Char>(&*range.begin, internal::to_unsigned(range.end - range.begin));
     return range.end;
   }
 
   template <typename FormatContext>
-  auto format(const duration& d, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const duration &d, FormatContext &ctx) -> decltype(ctx.out())
+  {
     auto begin = format_str.begin(), end = format_str.end();
     // As a possible future optimization, we could avoid extra copying if width
     // is not specified.
     basic_memory_buffer<Char> buf;
-    auto out = std::back_inserter(buf);
-    using range = internal::output_range<decltype(ctx.out()), Char>;
+    auto                      out = std::back_inserter(buf);
+    using range                   = internal::output_range<decltype(ctx.out()), Char>;
     internal::basic_writer<range> w(range(ctx.out()));
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs.width, width_ref, ctx, format_str.begin());
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        precision, precision_ref, ctx, format_str.begin());
+    internal::handle_dynamic_spec<internal::width_checker>(specs.width, width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(precision, precision_ref, ctx);
     if (begin == end || *begin == '}') {
       out = internal::format_chrono_duration_value(out, d.count(), precision);
       internal::format_chrono_duration_unit<Period>(out);
-    } else {
-      internal::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
-          ctx, out, d);
+    }
+    else {
+      internal::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(ctx, out, d);
       f.precision = precision;
       parse_chrono_format(begin, end, f);
     }
@@ -826,4 +815,4 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
 
 FMT_END_NAMESPACE
 
-#endif  // FMT_CHRONO_H_
+#endif // FMT_CHRONO_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/color.h b/packages/seacas/libraries/ioss/src/fmt/color.h
index d9d315599f01..72f99617b99f 100644
--- a/packages/seacas/libraries/ioss/src/fmt/color.h
+++ b/packages/seacas/libraries/ioss/src/fmt/color.h
@@ -13,148 +13,148 @@
 FMT_BEGIN_NAMESPACE
 
 enum class color : uint32_t {
-  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
-  antique_white = 0xFAEBD7,            // rgb(250,235,215)
-  aqua = 0x00FFFF,                     // rgb(0,255,255)
-  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
-  azure = 0xF0FFFF,                    // rgb(240,255,255)
-  beige = 0xF5F5DC,                    // rgb(245,245,220)
-  bisque = 0xFFE4C4,                   // rgb(255,228,196)
-  black = 0x000000,                    // rgb(0,0,0)
-  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
-  blue = 0x0000FF,                     // rgb(0,0,255)
-  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
-  brown = 0xA52A2A,                    // rgb(165,42,42)
-  burly_wood = 0xDEB887,               // rgb(222,184,135)
-  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
-  chartreuse = 0x7FFF00,               // rgb(127,255,0)
-  chocolate = 0xD2691E,                // rgb(210,105,30)
-  coral = 0xFF7F50,                    // rgb(255,127,80)
-  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
-  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
-  crimson = 0xDC143C,                  // rgb(220,20,60)
-  cyan = 0x00FFFF,                     // rgb(0,255,255)
-  dark_blue = 0x00008B,                // rgb(0,0,139)
-  dark_cyan = 0x008B8B,                // rgb(0,139,139)
-  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
-  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
-  dark_green = 0x006400,               // rgb(0,100,0)
-  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
-  dark_magenta = 0x8B008B,             // rgb(139,0,139)
-  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
-  dark_orange = 0xFF8C00,              // rgb(255,140,0)
-  dark_orchid = 0x9932CC,              // rgb(153,50,204)
-  dark_red = 0x8B0000,                 // rgb(139,0,0)
-  dark_salmon = 0xE9967A,              // rgb(233,150,122)
-  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
-  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
-  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
-  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
-  dark_violet = 0x9400D3,              // rgb(148,0,211)
-  deep_pink = 0xFF1493,                // rgb(255,20,147)
-  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
-  dim_gray = 0x696969,                 // rgb(105,105,105)
-  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
-  fire_brick = 0xB22222,               // rgb(178,34,34)
-  floral_white = 0xFFFAF0,             // rgb(255,250,240)
-  forest_green = 0x228B22,             // rgb(34,139,34)
-  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
-  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
-  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
-  gold = 0xFFD700,                     // rgb(255,215,0)
-  golden_rod = 0xDAA520,               // rgb(218,165,32)
-  gray = 0x808080,                     // rgb(128,128,128)
-  green = 0x008000,                    // rgb(0,128,0)
-  green_yellow = 0xADFF2F,             // rgb(173,255,47)
-  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
-  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
-  indian_red = 0xCD5C5C,               // rgb(205,92,92)
-  indigo = 0x4B0082,                   // rgb(75,0,130)
-  ivory = 0xFFFFF0,                    // rgb(255,255,240)
-  khaki = 0xF0E68C,                    // rgb(240,230,140)
-  lavender = 0xE6E6FA,                 // rgb(230,230,250)
-  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
-  lawn_green = 0x7CFC00,               // rgb(124,252,0)
-  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
-  light_blue = 0xADD8E6,               // rgb(173,216,230)
-  light_coral = 0xF08080,              // rgb(240,128,128)
-  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
-  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
-  light_gray = 0xD3D3D3,               // rgb(211,211,211)
-  light_green = 0x90EE90,              // rgb(144,238,144)
-  light_pink = 0xFFB6C1,               // rgb(255,182,193)
-  light_salmon = 0xFFA07A,             // rgb(255,160,122)
-  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
-  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
-  light_slate_gray = 0x778899,         // rgb(119,136,153)
-  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
-  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
-  lime = 0x00FF00,                     // rgb(0,255,0)
-  lime_green = 0x32CD32,               // rgb(50,205,50)
-  linen = 0xFAF0E6,                    // rgb(250,240,230)
-  magenta = 0xFF00FF,                  // rgb(255,0,255)
-  maroon = 0x800000,                   // rgb(128,0,0)
-  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
-  medium_blue = 0x0000CD,              // rgb(0,0,205)
-  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
-  medium_purple = 0x9370DB,            // rgb(147,112,219)
-  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
-  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
-  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
-  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
-  medium_violet_red = 0xC71585,        // rgb(199,21,133)
-  midnight_blue = 0x191970,            // rgb(25,25,112)
-  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
-  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
-  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
-  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
-  navy = 0x000080,                     // rgb(0,0,128)
-  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
-  olive = 0x808000,                    // rgb(128,128,0)
-  olive_drab = 0x6B8E23,               // rgb(107,142,35)
-  orange = 0xFFA500,                   // rgb(255,165,0)
-  orange_red = 0xFF4500,               // rgb(255,69,0)
-  orchid = 0xDA70D6,                   // rgb(218,112,214)
-  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
-  pale_green = 0x98FB98,               // rgb(152,251,152)
-  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
-  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
-  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
-  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
-  peru = 0xCD853F,                     // rgb(205,133,63)
-  pink = 0xFFC0CB,                     // rgb(255,192,203)
-  plum = 0xDDA0DD,                     // rgb(221,160,221)
-  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
-  purple = 0x800080,                   // rgb(128,0,128)
-  rebecca_purple = 0x663399,           // rgb(102,51,153)
-  red = 0xFF0000,                      // rgb(255,0,0)
-  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
-  royal_blue = 0x4169E1,               // rgb(65,105,225)
-  saddle_brown = 0x8B4513,             // rgb(139,69,19)
-  salmon = 0xFA8072,                   // rgb(250,128,114)
-  sandy_brown = 0xF4A460,              // rgb(244,164,96)
-  sea_green = 0x2E8B57,                // rgb(46,139,87)
-  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
-  sienna = 0xA0522D,                   // rgb(160,82,45)
-  silver = 0xC0C0C0,                   // rgb(192,192,192)
-  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
-  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
-  slate_gray = 0x708090,               // rgb(112,128,144)
-  snow = 0xFFFAFA,                     // rgb(255,250,250)
-  spring_green = 0x00FF7F,             // rgb(0,255,127)
-  steel_blue = 0x4682B4,               // rgb(70,130,180)
-  tan = 0xD2B48C,                      // rgb(210,180,140)
-  teal = 0x008080,                     // rgb(0,128,128)
-  thistle = 0xD8BFD8,                  // rgb(216,191,216)
-  tomato = 0xFF6347,                   // rgb(255,99,71)
-  turquoise = 0x40E0D0,                // rgb(64,224,208)
-  violet = 0xEE82EE,                   // rgb(238,130,238)
-  wheat = 0xF5DEB3,                    // rgb(245,222,179)
-  white = 0xFFFFFF,                    // rgb(255,255,255)
-  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
-  yellow = 0xFFFF00,                   // rgb(255,255,0)
-  yellow_green = 0x9ACD32              // rgb(154,205,50)
-};                                     // enum class color
+  alice_blue              = 0xF0F8FF, // rgb(240,248,255)
+  antique_white           = 0xFAEBD7, // rgb(250,235,215)
+  aqua                    = 0x00FFFF, // rgb(0,255,255)
+  aquamarine              = 0x7FFFD4, // rgb(127,255,212)
+  azure                   = 0xF0FFFF, // rgb(240,255,255)
+  beige                   = 0xF5F5DC, // rgb(245,245,220)
+  bisque                  = 0xFFE4C4, // rgb(255,228,196)
+  black                   = 0x000000, // rgb(0,0,0)
+  blanched_almond         = 0xFFEBCD, // rgb(255,235,205)
+  blue                    = 0x0000FF, // rgb(0,0,255)
+  blue_violet             = 0x8A2BE2, // rgb(138,43,226)
+  brown                   = 0xA52A2A, // rgb(165,42,42)
+  burly_wood              = 0xDEB887, // rgb(222,184,135)
+  cadet_blue              = 0x5F9EA0, // rgb(95,158,160)
+  chartreuse              = 0x7FFF00, // rgb(127,255,0)
+  chocolate               = 0xD2691E, // rgb(210,105,30)
+  coral                   = 0xFF7F50, // rgb(255,127,80)
+  cornflower_blue         = 0x6495ED, // rgb(100,149,237)
+  cornsilk                = 0xFFF8DC, // rgb(255,248,220)
+  crimson                 = 0xDC143C, // rgb(220,20,60)
+  cyan                    = 0x00FFFF, // rgb(0,255,255)
+  dark_blue               = 0x00008B, // rgb(0,0,139)
+  dark_cyan               = 0x008B8B, // rgb(0,139,139)
+  dark_golden_rod         = 0xB8860B, // rgb(184,134,11)
+  dark_gray               = 0xA9A9A9, // rgb(169,169,169)
+  dark_green              = 0x006400, // rgb(0,100,0)
+  dark_khaki              = 0xBDB76B, // rgb(189,183,107)
+  dark_magenta            = 0x8B008B, // rgb(139,0,139)
+  dark_olive_green        = 0x556B2F, // rgb(85,107,47)
+  dark_orange             = 0xFF8C00, // rgb(255,140,0)
+  dark_orchid             = 0x9932CC, // rgb(153,50,204)
+  dark_red                = 0x8B0000, // rgb(139,0,0)
+  dark_salmon             = 0xE9967A, // rgb(233,150,122)
+  dark_sea_green          = 0x8FBC8F, // rgb(143,188,143)
+  dark_slate_blue         = 0x483D8B, // rgb(72,61,139)
+  dark_slate_gray         = 0x2F4F4F, // rgb(47,79,79)
+  dark_turquoise          = 0x00CED1, // rgb(0,206,209)
+  dark_violet             = 0x9400D3, // rgb(148,0,211)
+  deep_pink               = 0xFF1493, // rgb(255,20,147)
+  deep_sky_blue           = 0x00BFFF, // rgb(0,191,255)
+  dim_gray                = 0x696969, // rgb(105,105,105)
+  dodger_blue             = 0x1E90FF, // rgb(30,144,255)
+  fire_brick              = 0xB22222, // rgb(178,34,34)
+  floral_white            = 0xFFFAF0, // rgb(255,250,240)
+  forest_green            = 0x228B22, // rgb(34,139,34)
+  fuchsia                 = 0xFF00FF, // rgb(255,0,255)
+  gainsboro               = 0xDCDCDC, // rgb(220,220,220)
+  ghost_white             = 0xF8F8FF, // rgb(248,248,255)
+  gold                    = 0xFFD700, // rgb(255,215,0)
+  golden_rod              = 0xDAA520, // rgb(218,165,32)
+  gray                    = 0x808080, // rgb(128,128,128)
+  green                   = 0x008000, // rgb(0,128,0)
+  green_yellow            = 0xADFF2F, // rgb(173,255,47)
+  honey_dew               = 0xF0FFF0, // rgb(240,255,240)
+  hot_pink                = 0xFF69B4, // rgb(255,105,180)
+  indian_red              = 0xCD5C5C, // rgb(205,92,92)
+  indigo                  = 0x4B0082, // rgb(75,0,130)
+  ivory                   = 0xFFFFF0, // rgb(255,255,240)
+  khaki                   = 0xF0E68C, // rgb(240,230,140)
+  lavender                = 0xE6E6FA, // rgb(230,230,250)
+  lavender_blush          = 0xFFF0F5, // rgb(255,240,245)
+  lawn_green              = 0x7CFC00, // rgb(124,252,0)
+  lemon_chiffon           = 0xFFFACD, // rgb(255,250,205)
+  light_blue              = 0xADD8E6, // rgb(173,216,230)
+  light_coral             = 0xF08080, // rgb(240,128,128)
+  light_cyan              = 0xE0FFFF, // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
+  light_gray              = 0xD3D3D3, // rgb(211,211,211)
+  light_green             = 0x90EE90, // rgb(144,238,144)
+  light_pink              = 0xFFB6C1, // rgb(255,182,193)
+  light_salmon            = 0xFFA07A, // rgb(255,160,122)
+  light_sea_green         = 0x20B2AA, // rgb(32,178,170)
+  light_sky_blue          = 0x87CEFA, // rgb(135,206,250)
+  light_slate_gray        = 0x778899, // rgb(119,136,153)
+  light_steel_blue        = 0xB0C4DE, // rgb(176,196,222)
+  light_yellow            = 0xFFFFE0, // rgb(255,255,224)
+  lime                    = 0x00FF00, // rgb(0,255,0)
+  lime_green              = 0x32CD32, // rgb(50,205,50)
+  linen                   = 0xFAF0E6, // rgb(250,240,230)
+  magenta                 = 0xFF00FF, // rgb(255,0,255)
+  maroon                  = 0x800000, // rgb(128,0,0)
+  medium_aquamarine       = 0x66CDAA, // rgb(102,205,170)
+  medium_blue             = 0x0000CD, // rgb(0,0,205)
+  medium_orchid           = 0xBA55D3, // rgb(186,85,211)
+  medium_purple           = 0x9370DB, // rgb(147,112,219)
+  medium_sea_green        = 0x3CB371, // rgb(60,179,113)
+  medium_slate_blue       = 0x7B68EE, // rgb(123,104,238)
+  medium_spring_green     = 0x00FA9A, // rgb(0,250,154)
+  medium_turquoise        = 0x48D1CC, // rgb(72,209,204)
+  medium_violet_red       = 0xC71585, // rgb(199,21,133)
+  midnight_blue           = 0x191970, // rgb(25,25,112)
+  mint_cream              = 0xF5FFFA, // rgb(245,255,250)
+  misty_rose              = 0xFFE4E1, // rgb(255,228,225)
+  moccasin                = 0xFFE4B5, // rgb(255,228,181)
+  navajo_white            = 0xFFDEAD, // rgb(255,222,173)
+  navy                    = 0x000080, // rgb(0,0,128)
+  old_lace                = 0xFDF5E6, // rgb(253,245,230)
+  olive                   = 0x808000, // rgb(128,128,0)
+  olive_drab              = 0x6B8E23, // rgb(107,142,35)
+  orange                  = 0xFFA500, // rgb(255,165,0)
+  orange_red              = 0xFF4500, // rgb(255,69,0)
+  orchid                  = 0xDA70D6, // rgb(218,112,214)
+  pale_golden_rod         = 0xEEE8AA, // rgb(238,232,170)
+  pale_green              = 0x98FB98, // rgb(152,251,152)
+  pale_turquoise          = 0xAFEEEE, // rgb(175,238,238)
+  pale_violet_red         = 0xDB7093, // rgb(219,112,147)
+  papaya_whip             = 0xFFEFD5, // rgb(255,239,213)
+  peach_puff              = 0xFFDAB9, // rgb(255,218,185)
+  peru                    = 0xCD853F, // rgb(205,133,63)
+  pink                    = 0xFFC0CB, // rgb(255,192,203)
+  plum                    = 0xDDA0DD, // rgb(221,160,221)
+  powder_blue             = 0xB0E0E6, // rgb(176,224,230)
+  purple                  = 0x800080, // rgb(128,0,128)
+  rebecca_purple          = 0x663399, // rgb(102,51,153)
+  red                     = 0xFF0000, // rgb(255,0,0)
+  rosy_brown              = 0xBC8F8F, // rgb(188,143,143)
+  royal_blue              = 0x4169E1, // rgb(65,105,225)
+  saddle_brown            = 0x8B4513, // rgb(139,69,19)
+  salmon                  = 0xFA8072, // rgb(250,128,114)
+  sandy_brown             = 0xF4A460, // rgb(244,164,96)
+  sea_green               = 0x2E8B57, // rgb(46,139,87)
+  sea_shell               = 0xFFF5EE, // rgb(255,245,238)
+  sienna                  = 0xA0522D, // rgb(160,82,45)
+  silver                  = 0xC0C0C0, // rgb(192,192,192)
+  sky_blue                = 0x87CEEB, // rgb(135,206,235)
+  slate_blue              = 0x6A5ACD, // rgb(106,90,205)
+  slate_gray              = 0x708090, // rgb(112,128,144)
+  snow                    = 0xFFFAFA, // rgb(255,250,250)
+  spring_green            = 0x00FF7F, // rgb(0,255,127)
+  steel_blue              = 0x4682B4, // rgb(70,130,180)
+  tan                     = 0xD2B48C, // rgb(210,180,140)
+  teal                    = 0x008080, // rgb(0,128,128)
+  thistle                 = 0xD8BFD8, // rgb(216,191,216)
+  tomato                  = 0xFF6347, // rgb(255,99,71)
+  turquoise               = 0x40E0D0, // rgb(64,224,208)
+  violet                  = 0xEE82EE, // rgb(238,130,238)
+  wheat                   = 0xF5DEB3, // rgb(245,222,179)
+  white                   = 0xFFFFFF, // rgb(255,255,255)
+  white_smoke             = 0xF5F5F5, // rgb(245,245,245)
+  yellow                  = 0xFFFF00, // rgb(255,255,0)
+  yellow_green            = 0x9ACD32  // rgb(154,205,50)
+};                                    // enum class color
 
 enum class terminal_color : uint8_t {
   black = 30,
@@ -176,23 +176,23 @@ enum class terminal_color : uint8_t {
 };
 
 enum class emphasis : uint8_t {
-  bold = 1,
-  italic = 1 << 1,
-  underline = 1 << 2,
+  bold          = 1,
+  italic        = 1 << 1,
+  underline     = 1 << 2,
   strikethrough = 1 << 3
 };
 
 // rgb is a struct for red, green and blue colors.
 // Using the name "rgb" makes some editors show the color in a tooltip.
-struct rgb {
+struct rgb
+{
   FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
   FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
-  FMT_CONSTEXPR rgb(uint32_t hex)
-      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(uint32_t hex) : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
   FMT_CONSTEXPR rgb(color hex)
-      : r((uint32_t(hex) >> 16) & 0xFF),
-        g((uint32_t(hex) >> 8) & 0xFF),
-        b(uint32_t(hex) & 0xFF) {}
+      : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), b(uint32_t(hex) & 0xFF)
+  {
+  }
   uint8_t r;
   uint8_t g;
   uint8_t b;
@@ -200,42 +200,48 @@ struct rgb {
 
 namespace internal {
 
-// color is a struct of either a rgb color or a terminal color.
-struct color_type {
-  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
-  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
-                                                           value{} {
-    value.rgb_color = static_cast<uint32_t>(rgb_color);
-  }
-  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
-    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
-                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
-  }
-  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
-                                                                     value{} {
-    value.term_color = static_cast<uint8_t>(term_color);
-  }
-  bool is_rgb;
-  union color_union {
-    uint8_t term_color;
-    uint32_t rgb_color;
-  } value;
-};
-}  // namespace internal
+  // color is a struct of either a rgb color or a terminal color.
+  struct color_type
+  {
+    FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+    FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true), value{}
+    {
+      value.rgb_color = static_cast<uint32_t>(rgb_color);
+    }
+    FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{}
+    {
+      value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                        (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+    }
+    FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(), value{}
+    {
+      value.term_color = static_cast<uint8_t>(term_color);
+    }
+    bool is_rgb;
+    union color_union {
+      uint8_t  term_color;
+      uint32_t rgb_color;
+    } value;
+  };
+} // namespace internal
 
 // Experimental text formatting support.
-class text_style {
- public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
-      : set_foreground_color(),
-        set_background_color(),
-        ems(em) {}
+class text_style
+{
+public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT : set_foreground_color(),
+                                                                    set_background_color(),
+                                                                    ems(em)
+  {
+  }
 
-  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+  FMT_CONSTEXPR text_style &operator|=(const text_style &rhs)
+  {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
+      foreground_color     = rhs.foreground_color;
+    }
+    else if (rhs.set_foreground_color) {
       if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
         FMT_THROW(format_error("can't OR a terminal color"));
       foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
@@ -243,28 +249,30 @@ class text_style {
 
     if (!set_background_color) {
       set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
+      background_color     = rhs.background_color;
+    }
+    else if (rhs.set_background_color) {
       if (!background_color.is_rgb || !rhs.background_color.is_rgb)
         FMT_THROW(format_error("can't OR a terminal color"));
       background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
     }
 
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
-                                static_cast<uint8_t>(rhs.ems));
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) | static_cast<uint8_t>(rhs.ems));
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
-                                            const text_style& rhs) {
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs, const text_style &rhs)
+  {
     return lhs |= rhs;
   }
 
-  FMT_CONSTEXPR text_style& operator&=(const text_style& rhs) {
+  FMT_CONSTEXPR text_style &operator&=(const text_style &rhs)
+  {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
+      foreground_color     = rhs.foreground_color;
+    }
+    else if (rhs.set_foreground_color) {
       if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
         FMT_THROW(format_error("can't AND a terminal color"));
       foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
@@ -272,256 +280,247 @@ class text_style {
 
     if (!set_background_color) {
       set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
+      background_color     = rhs.background_color;
+    }
+    else if (rhs.set_background_color) {
       if (!background_color.is_rgb || !rhs.background_color.is_rgb)
         FMT_THROW(format_error("can't AND a terminal color"));
       background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
     }
 
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
-                                static_cast<uint8_t>(rhs.ems));
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) & static_cast<uint8_t>(rhs.ems));
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator&(text_style lhs,
-                                            const text_style& rhs) {
+  friend FMT_CONSTEXPR text_style operator&(text_style lhs, const text_style &rhs)
+  {
     return lhs &= rhs;
   }
 
-  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
-    return set_foreground_color;
-  }
-  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
-    return set_background_color;
-  }
-  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
-    return static_cast<uint8_t>(ems) != 0;
-  }
-  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT { return set_foreground_color; }
+  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT { return set_background_color; }
+  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT { return static_cast<uint8_t>(ems) != 0; }
+  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT
+  {
     assert(has_foreground() && "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT
+  {
     assert(has_background() && "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT
+  {
     assert(has_emphasis() && "no emphasis specified for this style");
     return ems;
   }
 
- private:
-  FMT_CONSTEXPR text_style(bool is_foreground,
-                           internal::color_type text_color) FMT_NOEXCEPT
+private:
+  FMT_CONSTEXPR text_style(bool is_foreground, internal::color_type text_color) FMT_NOEXCEPT
       : set_foreground_color(),
         set_background_color(),
-        ems() {
+        ems()
+  {
     if (is_foreground) {
-      foreground_color = text_color;
+      foreground_color     = text_color;
       set_foreground_color = true;
-    } else {
-      background_color = text_color;
+    }
+    else {
+      background_color     = text_color;
       set_background_color = true;
     }
   }
 
-  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
-      FMT_NOEXCEPT;
-  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background)
-      FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground) FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background) FMT_NOEXCEPT;
 
   internal::color_type foreground_color;
   internal::color_type background_color;
-  bool set_foreground_color;
-  bool set_background_color;
-  emphasis ems;
+  bool                 set_foreground_color;
+  bool                 set_background_color;
+  emphasis             ems;
 };
 
-FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT {
+FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT
+{
   return text_style(/*is_foreground=*/true, foreground);
 }
 
-FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT {
+FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT
+{
   return text_style(/*is_foreground=*/false, background);
 }
 
-FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
+FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT
+{
   return text_style(lhs) | rhs;
 }
 
 namespace internal {
 
-template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
-                                  const char* esc) FMT_NOEXCEPT {
-    // If we have a terminal color, we need to output another escape code
-    // sequence.
-    if (!text_color.is_rgb) {
-      bool is_background = esc == internal::data::background_color;
-      uint32_t value = text_color.value.term_color;
-      // Background ASCII codes are the same as the foreground ones but with
-      // 10 more.
-      if (is_background) value += 10u;
-
-      std::size_t index = 0;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-
-      if (value >= 100u) {
-        buffer[index++] = static_cast<Char>('1');
-        value %= 100u;
+  template <typename Char> struct ansi_color_escape
+  {
+    FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color, const char *esc) FMT_NOEXCEPT
+    {
+      // If we have a terminal color, we need to output another escape code
+      // sequence.
+      if (!text_color.is_rgb) {
+        bool     is_background = esc == internal::data::background_color;
+        uint32_t value         = text_color.value.term_color;
+        // Background ASCII codes are the same as the foreground ones but with
+        // 10 more.
+        if (is_background)
+          value += 10u;
+
+        std::size_t index = 0;
+        buffer[index++]   = static_cast<Char>('\x1b');
+        buffer[index++]   = static_cast<Char>('[');
+
+        if (value >= 100u) {
+          buffer[index++] = static_cast<Char>('1');
+          value %= 100u;
+        }
+        buffer[index++] = static_cast<Char>('0' + value / 10u);
+        buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+        buffer[index++] = static_cast<Char>('m');
+        buffer[index++] = static_cast<Char>('\0');
+        return;
       }
-      buffer[index++] = static_cast<Char>('0' + value / 10u);
-      buffer[index++] = static_cast<Char>('0' + value % 10u);
 
-      buffer[index++] = static_cast<Char>('m');
-      buffer[index++] = static_cast<Char>('\0');
-      return;
+      for (int i = 0; i < 7; i++) {
+        buffer[i] = static_cast<Char>(esc[i]);
+      }
+      rgb color(text_color.value.rgb_color);
+      to_esc(color.r, buffer + 7, ';');
+      to_esc(color.g, buffer + 11, ';');
+      to_esc(color.b, buffer + 15, 'm');
+      buffer[19] = static_cast<Char>(0);
     }
+    FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT
+    {
+      uint8_t em_codes[4] = {};
+      uint8_t em_bits     = static_cast<uint8_t>(em);
+      if (em_bits & static_cast<uint8_t>(emphasis::bold))
+        em_codes[0] = 1;
+      if (em_bits & static_cast<uint8_t>(emphasis::italic))
+        em_codes[1] = 3;
+      if (em_bits & static_cast<uint8_t>(emphasis::underline))
+        em_codes[2] = 4;
+      if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+        em_codes[3] = 9;
 
-    for (int i = 0; i < 7; i++) {
-      buffer[i] = static_cast<Char>(esc[i]);
-    }
-    rgb color(text_color.value.rgb_color);
-    to_esc(color.r, buffer + 7, ';');
-    to_esc(color.g, buffer + 11, ';');
-    to_esc(color.b, buffer + 15, 'm');
-    buffer[19] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
-    uint8_t em_codes[4] = {};
-    uint8_t em_bits = static_cast<uint8_t>(em);
-    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
-    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
-    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
-      em_codes[3] = 9;
-
-    std::size_t index = 0;
-    for (int i = 0; i < 4; ++i) {
-      if (!em_codes[i]) continue;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
-      buffer[index++] = static_cast<Char>('m');
+      std::size_t index = 0;
+      for (int i = 0; i < 4; ++i) {
+        if (!em_codes[i])
+          continue;
+        buffer[index++] = static_cast<Char>('\x1b');
+        buffer[index++] = static_cast<Char>('[');
+        buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+        buffer[index++] = static_cast<Char>('m');
+      }
+      buffer[index++] = static_cast<Char>(0);
     }
-    buffer[index++] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
-
-  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
-  FMT_CONSTEXPR const Char* end() const FMT_NOEXCEPT {
-    return buffer + std::strlen(buffer);
-  }
+    FMT_CONSTEXPR operator const Char *() const FMT_NOEXCEPT { return buffer; }
 
- private:
-  Char buffer[7u + 3u * 4u + 1u];
+    FMT_CONSTEXPR const Char *begin() const FMT_NOEXCEPT { return buffer; }
+    FMT_CONSTEXPR const Char *end() const FMT_NOEXCEPT { return buffer + std::strlen(buffer); }
 
-  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) FMT_NOEXCEPT {
-    out[0] = static_cast<Char>('0' + c / 100);
-    out[1] = static_cast<Char>('0' + c / 10 % 10);
-    out[2] = static_cast<Char>('0' + c % 10);
-    out[3] = static_cast<Char>(delimiter);
-  }
-};
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    internal::color_type foreground) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(foreground, internal::data::foreground_color);
-}
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-    internal::color_type background) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(background, internal::data::background_color);
-}
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(em);
-}
+  private:
+    Char buffer[7u + 3u * 4u + 1u];
 
-template <typename Char>
-inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputs(chars, stream);
-}
-
-template <>
-inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputws(chars, stream);
-}
-
-template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
-  fputs(internal::data::reset_color, stream);
-}
-
-template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
-  fputs(internal::data::wreset_color, stream);
-}
+    static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out, char delimiter) FMT_NOEXCEPT
+    {
+      out[0] = static_cast<Char>('0' + c / 100);
+      out[1] = static_cast<Char>('0' + c / 10 % 10);
+      out[2] = static_cast<Char>('0' + c % 10);
+      out[3] = static_cast<Char>(delimiter);
+    }
+  };
 
-template <typename Char>
-inline void reset_color(basic_memory_buffer<Char>& buffer) FMT_NOEXCEPT {
-  const char* begin = data::reset_color;
-  const char* end = begin + sizeof(data::reset_color) - 1;
-  buffer.append(begin, end);
-}
+  template <typename Char>
+  FMT_CONSTEXPR ansi_color_escape<Char>
+                make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT
+  {
+    return ansi_color_escape<Char>(foreground, internal::data::foreground_color);
+  }
 
-template <typename Char>
-std::basic_string<Char> vformat(const text_style& ts,
-                                basic_string_view<Char> format_str,
-                                basic_format_args<buffer_context<Char> > args) {
-  basic_memory_buffer<Char> buffer;
-  bool has_style = false;
-  if (ts.has_emphasis()) {
-    has_style = true;
-    ansi_color_escape<Char> escape = make_emphasis<Char>(ts.get_emphasis());
-    buffer.append(escape.begin(), escape.end());
+  template <typename Char>
+  FMT_CONSTEXPR ansi_color_escape<Char>
+                make_background_color(internal::color_type background) FMT_NOEXCEPT
+  {
+    return ansi_color_escape<Char>(background, internal::data::background_color);
   }
-  if (ts.has_foreground()) {
-    has_style = true;
-    ansi_color_escape<Char> escape =
-        make_foreground_color<Char>(ts.get_foreground());
-    buffer.append(escape.begin(), escape.end());
+
+  template <typename Char>
+  FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT
+  {
+    return ansi_color_escape<Char>(em);
   }
-  if (ts.has_background()) {
-    has_style = true;
-    ansi_color_escape<Char> escape =
-        make_background_color<Char>(ts.get_background());
-    buffer.append(escape.begin(), escape.end());
+
+  template <typename Char> inline void fputs(const Char *chars, FILE *stream) FMT_NOEXCEPT
+  {
+    std::fputs(chars, stream);
   }
-  internal::vformat_to(buffer, format_str, args);
-  if (has_style) {
-    reset_color<Char>(buffer);
+
+  template <> inline void fputs<wchar_t>(const wchar_t *chars, FILE *stream) FMT_NOEXCEPT
+  {
+    std::fputws(chars, stream);
   }
-  return fmt::to_string(buffer);
-}
-}  // namespace internal
-
-template <typename S, typename Char = char_t<S> >
-void vprint(std::FILE* f, const text_style& ts, const S& format,
-            basic_format_args<buffer_context<Char> > args) {
-  bool has_style = false;
-  if (ts.has_emphasis()) {
-    has_style = true;
-    internal::fputs<Char>(internal::make_emphasis<Char>(ts.get_emphasis()), f);
+
+  template <typename Char> inline void reset_color(FILE *stream) FMT_NOEXCEPT
+  {
+    fputs(internal::data::reset_color, stream);
   }
-  if (ts.has_foreground()) {
-    has_style = true;
-    internal::fputs<Char>(
-        internal::make_foreground_color<Char>(ts.get_foreground()), f);
+
+  template <> inline void reset_color<wchar_t>(FILE *stream) FMT_NOEXCEPT
+  {
+    fputs(internal::data::wreset_color, stream);
   }
-  if (ts.has_background()) {
-    has_style = true;
-    internal::fputs<Char>(
-        internal::make_background_color<Char>(ts.get_background()), f);
+
+  template <typename Char> inline void reset_color(basic_memory_buffer<Char> &buffer) FMT_NOEXCEPT
+  {
+    const char *begin = data::reset_color;
+    const char *end   = begin + sizeof(data::reset_color) - 1;
+    buffer.append(begin, end);
   }
-  vprint(f, format, args);
-  if (has_style) {
-    internal::reset_color<Char>(f);
+
+  template <typename Char>
+  void vformat_to(basic_memory_buffer<Char> &buf, const text_style &ts,
+                  basic_string_view<Char> format_str, basic_format_args<buffer_context<Char>> args)
+  {
+    bool has_style = false;
+    if (ts.has_emphasis()) {
+      has_style     = true;
+      auto emphasis = internal::make_emphasis<Char>(ts.get_emphasis());
+      buf.append(emphasis.begin(), emphasis.end());
+    }
+    if (ts.has_foreground()) {
+      has_style       = true;
+      auto foreground = internal::make_foreground_color<Char>(ts.get_foreground());
+      buf.append(foreground.begin(), foreground.end());
+    }
+    if (ts.has_background()) {
+      has_style       = true;
+      auto background = internal::make_background_color<Char>(ts.get_background());
+      buf.append(background.begin(), background.end());
+    }
+    vformat_to(buf, format_str, args);
+    if (has_style) {
+      internal::reset_color<Char>(buf);
+    }
   }
+} // namespace internal
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE *f, const text_style &ts, const S &format,
+            basic_format_args<buffer_context<Char>> args)
+{
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format), args);
+  buf.push_back(Char(0));
+  internal::fputs(buf.data(), f);
 }
 
 /**
@@ -531,12 +530,11 @@ void vprint(std::FILE* f, const text_style& ts, const S& format,
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-void print(std::FILE* f, const text_style& ts, const S& format_str,
-           const Args&... args) {
+template <typename S, typename... Args, FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(std::FILE *f, const text_style &ts, const S &format_str, const Args &... args)
+{
   internal::check_format_string<Args...>(format_str);
-  using context = buffer_context<char_t<S> >;
+  using context = buffer_context<char_t<S>>;
   format_arg_store<context, Args...> as{args...};
   vprint(f, ts, format_str, basic_format_args<context>(as));
 }
@@ -548,17 +546,19 @@ void print(std::FILE* f, const text_style& ts, const S& format_str,
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-void print(const text_style& ts, const S& format_str, const Args&... args) {
+template <typename S, typename... Args, FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(const text_style &ts, const S &format_str, const Args &... args)
+{
   return print(stdout, ts, format_str, args...);
 }
 
-template <typename S, typename Char = char_t<S> >
-inline std::basic_string<Char> vformat(
-    const text_style& ts, const S& format_str,
-    basic_format_args<buffer_context<Char> > args) {
-  return internal::vformat(ts, to_string_view(format_str), args);
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(const text_style &ts, const S &format_str,
+                                       basic_format_args<buffer_context<Char>> args)
+{
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format_str), args);
+  return fmt::to_string(buf);
 }
 
 /**
@@ -573,13 +573,14 @@ inline std::basic_string<Char> vformat(
                                       "The answer is {}", 42);
   \endrst
 */
-template <typename S, typename... Args, typename Char = char_t<S> >
-inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
-                                      const Args&... args) {
-  return internal::vformat(ts, to_string_view(format_str),
-                           {internal::make_args_checked(format_str, args...)});
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style &ts, const S &format_str,
+                                      const Args &... args)
+{
+  return vformat(ts, to_string_view(format_str),
+                 {internal::make_args_checked<Args...>(format_str, args...)});
 }
 
 FMT_END_NAMESPACE
 
-#endif  // FMT_COLOR_H_
+#endif // FMT_COLOR_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/compile.h b/packages/seacas/libraries/ioss/src/fmt/compile.h
index 39f64a899e66..ab94c20af985 100644
--- a/packages/seacas/libraries/ioss/src/fmt/compile.h
+++ b/packages/seacas/libraries/ioss/src/fmt/compile.h
@@ -14,462 +14,574 @@
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
+  // Part of a compiled format string. It can be either literal text or a
+  // replacement field.
   template <typename Char> struct format_part
   {
-  public:
-    struct named_argument_id
-    {
-      FMT_CONSTEXPR named_argument_id(internal::string_view_metadata id) : id(id) {}
-      internal::string_view_metadata id;
-    };
+    enum class kind { arg_index, arg_name, text, replacement };
 
-    struct argument_id
+    struct replacement
     {
-      FMT_CONSTEXPR argument_id() : argument_id(0u) {}
-
-      FMT_CONSTEXPR argument_id(unsigned id) : which(which_arg_id::index), val(id) {}
-
-      FMT_CONSTEXPR argument_id(internal::string_view_metadata id)
-          : which(which_arg_id::named_index), val(id)
-      {
-      }
-
-      enum class which_arg_id { index, named_index };
-
-      which_arg_id which;
-
-      union value {
-        FMT_CONSTEXPR value() : index(0u) {}
-        FMT_CONSTEXPR value(unsigned id) : index(id) {}
-        FMT_CONSTEXPR value(internal::string_view_metadata id) : named_index(id) {}
-
-        unsigned                       index;
-        internal::string_view_metadata named_index;
-      } val;
+      arg_ref<Char>              arg_id;
+      dynamic_format_specs<Char> specs;
     };
 
-    struct specification
-    {
-      FMT_CONSTEXPR specification() : arg_id(0u) {}
-      FMT_CONSTEXPR specification(unsigned id) : arg_id(id) {}
-
-      FMT_CONSTEXPR specification(internal::string_view_metadata id) : arg_id(id) {}
+    kind part_kind;
+    union value {
+      unsigned                arg_index;
+      basic_string_view<Char> str;
+      replacement             repl;
 
-      argument_id                          arg_id;
-      internal::dynamic_format_specs<Char> parsed_specs;
-    };
+      FMT_CONSTEXPR value(unsigned index = 0) : arg_index(index) {}
+      FMT_CONSTEXPR value(basic_string_view<Char> s) : str(s) {}
+      FMT_CONSTEXPR value(replacement r) : repl(r) {}
+    } val;
+    // Position past the end of the argument id.
+    const Char *arg_id_end = nullptr;
 
-    FMT_CONSTEXPR format_part() : which(kind::argument_id), end_of_argument_id(0u), val(0u) {}
+    FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {}) : part_kind(k), val(v) {}
 
-    FMT_CONSTEXPR format_part(internal::string_view_metadata text)
-        : which(kind::text), end_of_argument_id(0u), val(text)
+    static FMT_CONSTEXPR format_part make_arg_index(unsigned index)
     {
+      return format_part(kind::arg_index, index);
     }
-
-    FMT_CONSTEXPR format_part(unsigned id)
-        : which(kind::argument_id), end_of_argument_id(0u), val(id)
+    static FMT_CONSTEXPR format_part make_arg_name(basic_string_view<Char> name)
     {
+      return format_part(kind::arg_name, name);
     }
-
-    FMT_CONSTEXPR format_part(named_argument_id arg_id)
-        : which(kind::named_argument_id), end_of_argument_id(0u), val(arg_id)
+    static FMT_CONSTEXPR format_part make_text(basic_string_view<Char> text)
     {
+      return format_part(kind::text, text);
     }
+    static FMT_CONSTEXPR format_part make_replacement(replacement repl)
+    {
+      return format_part(kind::replacement, repl);
+    }
+  };
 
-    FMT_CONSTEXPR format_part(specification spec)
-        : which(kind::specification), end_of_argument_id(0u), val(spec)
+  template <typename Char> struct part_counter
+  {
+    unsigned num_parts = 0;
+
+    FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
     {
+      if (begin != end)
+        ++num_parts;
     }
 
-    enum class kind { argument_id, named_argument_id, text, specification };
+    FMT_CONSTEXPR void on_arg_id() { ++num_parts; }
+    FMT_CONSTEXPR void on_arg_id(unsigned) { ++num_parts; }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) { ++num_parts; }
 
-    kind        which;
-    std::size_t end_of_argument_id;
-    union value {
-      FMT_CONSTEXPR value() : arg_id(0u) {}
-      FMT_CONSTEXPR value(unsigned id) : arg_id(id) {}
-      FMT_CONSTEXPR value(named_argument_id named_id) : named_arg_id(named_id.id) {}
-      FMT_CONSTEXPR value(internal::string_view_metadata t) : text(t) {}
-      FMT_CONSTEXPR value(specification s) : spec(s) {}
-      unsigned      arg_id;
-      internal::string_view_metadata named_arg_id;
-      internal::string_view_metadata text;
-      specification                  spec;
-    } val;
+    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
+
+    FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *end)
+    {
+      // Find the matching brace.
+      unsigned brace_counter = 0;
+      for (; begin != end; ++begin) {
+        if (*begin == '{') {
+          ++brace_counter;
+        }
+        else if (*begin == '}') {
+          if (brace_counter == 0u)
+            break;
+          --brace_counter;
+        }
+      }
+      return begin;
+    }
+
+    FMT_CONSTEXPR void on_error(const char *) {}
   };
 
-  template <typename Char, typename PartsContainer>
-  class format_preparation_handler : public internal::error_handler
+  // Counts the number of parts in a format string.
+  template <typename Char> FMT_CONSTEXPR unsigned count_parts(basic_string_view<Char> format_str)
+  {
+    part_counter<Char> counter;
+    parse_format_string<true>(format_str, counter);
+    return counter.num_parts;
+  }
+
+  template <typename Char, typename PartHandler> class format_string_compiler : public error_handler
   {
   private:
     using part = format_part<Char>;
 
-  public:
-    using iterator = typename basic_string_view<Char>::iterator;
+    PartHandler               handler_;
+    part                      part_;
+    basic_string_view<Char>   format_str_;
+    basic_parse_context<Char> parse_context_;
 
-    FMT_CONSTEXPR format_preparation_handler(basic_string_view<Char> format, PartsContainer &parts)
-        : parts_(parts), format_(format), parse_context_(format)
+  public:
+    FMT_CONSTEXPR format_string_compiler(basic_string_view<Char> format_str, PartHandler handler)
+        : handler_(handler), format_str_(format_str), parse_context_(format_str)
     {
     }
 
     FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
     {
-      if (begin == end)
-        return;
-      const auto offset = begin - format_.data();
-      const auto size   = end - begin;
-      parts_.push_back(part(string_view_metadata(offset, size)));
+      if (begin != end)
+        handler_(part::make_text({begin, to_unsigned(end - begin)}));
     }
 
-    FMT_CONSTEXPR void on_arg_id() { parts_.push_back(part(parse_context_.next_arg_id())); }
+    FMT_CONSTEXPR void on_arg_id() { part_ = part::make_arg_index(parse_context_.next_arg_id()); }
 
     FMT_CONSTEXPR void on_arg_id(unsigned id)
     {
       parse_context_.check_arg_id(id);
-      parts_.push_back(part(id));
+      part_ = part::make_arg_index(id);
     }
 
-    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id)
-    {
-      const auto view   = string_view_metadata(format_, id);
-      const auto arg_id = typename part::named_argument_id(view);
-      parts_.push_back(part(arg_id));
-    }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id) { part_ = part::make_arg_name(id); }
 
     FMT_CONSTEXPR void on_replacement_field(const Char *ptr)
     {
-      parts_.back().end_of_argument_id = ptr - format_.begin();
+      part_.arg_id_end = ptr;
+      handler_(part_);
     }
 
     FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *end)
     {
-      const auto specs_offset = to_unsigned(begin - format_.begin());
-
-      using parse_context = basic_parse_context<Char>;
-      internal::dynamic_format_specs<Char> parsed_specs;
-      dynamic_specs_handler<parse_context> handler(parsed_specs, parse_context_);
-      begin = parse_format_specs(begin, end, handler);
-
-      if (*begin != '}')
+      auto                                             repl = typename part::replacement();
+      dynamic_specs_handler<basic_parse_context<Char>> handler(repl.specs, parse_context_);
+      auto                                             it = parse_format_specs(begin, end, handler);
+      if (*it != '}')
         on_error("missing '}' in format string");
-
-      auto &last_part = parts_.back();
-      auto  specs     = last_part.which == part::kind::argument_id
-                       ? typename part::specification(last_part.val.arg_id)
-                       : typename part::specification(last_part.val.named_arg_id);
-      specs.parsed_specs           = parsed_specs;
-      last_part                    = part(specs);
-      last_part.end_of_argument_id = specs_offset;
-      return begin;
+      repl.arg_id = part_.part_kind == part::kind::arg_index ? arg_ref<Char>(part_.val.arg_index)
+                                                             : arg_ref<Char>(part_.val.str);
+      auto part       = part::make_replacement(repl);
+      part.arg_id_end = begin;
+      handler_(part);
+      return it;
     }
-
-  private:
-    PartsContainer &          parts_;
-    basic_string_view<Char>   format_;
-    basic_parse_context<Char> parse_context_;
   };
 
-  template <typename Format, typename PreparedPartsProvider, typename... Args> class prepared_format
+  // Compiles a format string and invokes handler(part) for each parsed part.
+  template <bool IS_CONSTEXPR, typename Char, typename PartHandler>
+  FMT_CONSTEXPR void compile_format_string(basic_string_view<Char> format_str, PartHandler handler)
   {
-  public:
-    using char_type     = char_t<Format>;
-    using format_part_t = format_part<char_type>;
-
-    constexpr prepared_format(Format f)
-        : format_(std::move(f)), parts_provider_(to_string_view(format_))
-    {
-    }
-
-    prepared_format() = delete;
+    parse_format_string<IS_CONSTEXPR>(
+        format_str, format_string_compiler<Char, PartHandler>(format_str, handler));
+  }
 
-    using context = buffer_context<char_type>;
+  template <typename Range, typename Context, typename Id>
+  void format_arg(basic_parse_context<typename Range::value_type> &parse_ctx, Context &ctx,
+                  Id arg_id)
+  {
+    ctx.advance_to(visit_format_arg(arg_formatter<Range>(ctx, &parse_ctx), ctx.arg(arg_id)));
+  }
 
-    template <typename Range, typename Context>
-    auto vformat_to(Range out, basic_format_args<Context> args) const -> typename Context::iterator
+  // vformat_to is defined in a subnamespace to prevent ADL.
+  namespace cf {
+    template <typename Context, typename Range, typename CompiledFormat>
+    auto vformat_to(Range out, CompiledFormat &cf, basic_format_args<Context> args) ->
+        typename Context::iterator
     {
-      const auto                     format_view = internal::to_string_view(format_);
-      basic_parse_context<char_type> parse_ctx(format_view);
+      using char_type = typename Context::char_type;
+      basic_parse_context<char_type> parse_ctx(to_string_view(cf.format_str_));
       Context                        ctx(out.begin(), args);
 
-      const auto &parts = parts_provider_.parts();
-      for (auto part_it = parts.begin(); part_it != parts.end(); ++part_it) {
+      const auto &parts = cf.parts();
+      for (auto part_it = std::begin(parts); part_it != std::end(parts); ++part_it) {
         const auto &part  = *part_it;
         const auto &value = part.val;
 
-        switch (part.which) {
+        using format_part_t = format_part<char_type>;
+        switch (part.part_kind) {
         case format_part_t::kind::text: {
-          const auto text   = value.text.to_view(format_view.data());
+          const auto text   = value.str;
           auto       output = ctx.out();
-          auto &&    it     = internal::reserve(output, text.size());
+          auto &&    it     = reserve(output, text.size());
           it                = std::copy_n(text.begin(), text.size(), it);
           ctx.advance_to(output);
-        } break;
-
-        case format_part_t::kind::argument_id: {
-          advance_parse_context_to_specification(parse_ctx, part);
-          format_arg<Range>(parse_ctx, ctx, value.arg_id);
-        } break;
-
-        case format_part_t::kind::named_argument_id: {
-          advance_parse_context_to_specification(parse_ctx, part);
-          const auto named_arg_id = value.named_arg_id.to_view(format_view.data());
-          format_arg<Range>(parse_ctx, ctx, named_arg_id);
-        } break;
-        case format_part_t::kind::specification: {
-          const auto &arg_id_value = value.spec.arg_id.val;
-          const auto  arg =
-              value.spec.arg_id.which == format_part_t::argument_id::which_arg_id::index
-                  ? ctx.arg(arg_id_value.index)
-                  : ctx.arg(arg_id_value.named_index.to_view(to_string_view(format_).data()));
-
-          auto specs = value.spec.parsed_specs;
-
-          handle_dynamic_spec<internal::width_checker>(specs.width, specs.width_ref, ctx,
-                                                       format_view.begin());
-          handle_dynamic_spec<internal::precision_checker>(specs.precision, specs.precision_ref,
-                                                           ctx, format_view.begin());
-
-          check_prepared_specs(specs, arg.type());
-          advance_parse_context_to_specification(parse_ctx, part);
+          break;
+        }
+
+        case format_part_t::kind::arg_index:
+          advance_to(parse_ctx, part.arg_id_end);
+          internal::format_arg<Range>(parse_ctx, ctx, value.arg_index);
+          break;
+
+        case format_part_t::kind::arg_name:
+          advance_to(parse_ctx, part.arg_id_end);
+          internal::format_arg<Range>(parse_ctx, ctx, value.str);
+          break;
+
+        case format_part_t::kind::replacement: {
+          const auto &arg_id_value = value.repl.arg_id.val;
+          const auto  arg          = value.repl.arg_id.kind == arg_id_kind::index
+                               ? ctx.arg(arg_id_value.index)
+                               : ctx.arg(arg_id_value.name);
+
+          auto specs = value.repl.specs;
+
+          handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx);
+          handle_dynamic_spec<precision_checker>(specs.precision, specs.precision_ref, ctx);
+
+          error_handler                        h;
+          numeric_specs_checker<error_handler> checker(h, arg.type());
+          if (specs.align == align::numeric)
+            checker.require_numeric_argument();
+          if (specs.sign != sign::none)
+            checker.check_sign();
+          if (specs.alt)
+            checker.require_numeric_argument();
+          if (specs.precision >= 0)
+            checker.check_precision();
+
+          advance_to(parse_ctx, part.arg_id_end);
           ctx.advance_to(visit_format_arg(arg_formatter<Range>(ctx, nullptr, &specs), arg));
-        } break;
+          break;
+        }
         }
       }
-
       return ctx.out();
     }
+  } // namespace cf
 
-  private:
-    void advance_parse_context_to_specification(basic_parse_context<char_type> &parse_ctx,
-                                                const format_part_t &           part) const
-    {
-      const auto view                = to_string_view(format_);
-      const auto specification_begin = view.data() + part.end_of_argument_id;
-      advance_to(parse_ctx, specification_begin);
-    }
+  struct basic_compiled_format
+  {
+  };
 
-    template <typename Range, typename Context, typename Id>
-    void format_arg(basic_parse_context<char_type> &parse_ctx, Context &ctx, Id arg_id) const
-    {
-      parse_ctx.check_arg_id(arg_id);
-      const auto stopped_at = visit_format_arg(arg_formatter<Range>(ctx), ctx.arg(arg_id));
-      ctx.advance_to(stopped_at);
-    }
+  template <typename S, typename = void> struct compiled_format_base : basic_compiled_format
+  {
+    using char_type       = char_t<S>;
+    using parts_container = std::vector<internal::format_part<char_type>>;
+
+    parts_container compiled_parts;
 
-    template <typename Char>
-    void check_prepared_specs(const basic_format_specs<Char> &specs, internal::type arg_type) const
+    explicit compiled_format_base(basic_string_view<char_type> format_str)
     {
-      internal::error_handler                        h;
-      numeric_specs_checker<internal::error_handler> checker(h, arg_type);
-      if (specs.align == align::numeric)
-        checker.require_numeric_argument();
-      if (specs.sign != sign::none)
-        checker.check_sign();
-      if (specs.alt)
-        checker.require_numeric_argument();
-      if (specs.precision >= 0)
-        checker.check_precision();
+      compile_format_string<false>(format_str, [this](const format_part<char_type> &part) {
+        compiled_parts.push_back(part);
+      });
     }
 
-  private:
-    Format                format_;
-    PreparedPartsProvider parts_provider_;
+    const parts_container &parts() const { return compiled_parts; }
   };
 
-  template <typename Char> struct part_counter
+  template <typename Char, unsigned N> struct format_part_array
   {
-    unsigned num_parts = 0;
+    format_part<Char> data[N]             = {};
+    FMT_CONSTEXPR     format_part_array() = default;
+  };
 
-    FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
+  template <typename Char, unsigned N>
+  FMT_CONSTEXPR format_part_array<Char, N> compile_to_parts(basic_string_view<Char> format_str)
+  {
+    format_part_array<Char, N> parts;
+    unsigned                   counter = 0;
+    // This is not a lambda for compatibility with older compilers.
+    struct
     {
-      if (begin != end)
-        ++num_parts;
+      format_part<Char> *parts;
+      unsigned *         counter;
+      FMT_CONSTEXPR void operator()(const format_part<Char> &part) { parts[(*counter)++] = part; }
+    } collector{parts.data, &counter};
+    compile_format_string<true>(format_str, collector);
+    if (counter < N) {
+      parts.data[counter] = format_part<Char>::make_text(basic_string_view<Char>());
     }
+    return parts;
+  }
 
-    FMT_CONSTEXPR void on_arg_id() { ++num_parts; }
-    FMT_CONSTEXPR void on_arg_id(unsigned) { ++num_parts; }
-    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) { ++num_parts; }
+  template <typename T> constexpr const T &constexpr_max(const T &a, const T &b)
+  {
+    return (a < b) ? b : a;
+  }
 
-    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
+  template <typename S>
+  struct compiled_format_base<S, enable_if_t<is_compile_string<S>::value>> : basic_compiled_format
+  {
+    using char_type = char_t<S>;
 
-    FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *end)
+    FMT_CONSTEXPR explicit compiled_format_base(basic_string_view<char_type>) {}
+
+// Workaround for old compilers. Format string compilation will not be
+// performed there anyway.
+#if FMT_USE_CONSTEXPR
+    static FMT_CONSTEXPR_DECL const unsigned num_format_parts =
+        constexpr_max(count_parts(to_string_view(S())), 1u);
+#else
+    static const unsigned num_format_parts = 1;
+#endif
+
+    using parts_container = format_part<char_type>[num_format_parts];
+
+    const parts_container &parts() const
     {
-      // Find the matching brace.
-      unsigned braces_counter = 0;
-      for (; begin != end; ++begin) {
-        if (*begin == '{') {
-          ++braces_counter;
-        }
-        else if (*begin == '}') {
-          if (braces_counter == 0u)
-            break;
-          --braces_counter;
-        }
-      }
-      return begin;
+      static FMT_CONSTEXPR_DECL const auto compiled_parts =
+          compile_to_parts<char_type, num_format_parts>(internal::to_string_view(S()));
+      return compiled_parts.data;
     }
-
-    FMT_CONSTEXPR void on_error(const char *) {}
   };
 
-  template <typename Format> class compiletime_prepared_parts_type_provider
+  template <typename S, typename... Args> class compiled_format : private compiled_format_base<S>
   {
-  private:
-    using char_type = char_t<Format>;
+  public:
+    using typename compiled_format_base<S>::char_type;
 
-    static FMT_CONSTEXPR unsigned count_parts()
-    {
-      FMT_CONSTEXPR_DECL const auto text = to_string_view(Format{});
-      part_counter<char_type>       counter;
-      internal::parse_format_string</*IS_CONSTEXPR=*/true>(text, counter);
-      return counter.num_parts;
-    }
+  private:
+    basic_string_view<char_type> format_str_;
 
-// Workaround for old compilers. Compile time parts preparation will not be
-// performed with them anyway.
-#if FMT_USE_CONSTEXPR
-    static FMT_CONSTEXPR_DECL const unsigned number_of_format_parts =
-        compiletime_prepared_parts_type_provider::count_parts();
-#else
-    static const unsigned number_of_format_parts = 0u;
-#endif
+    template <typename Context, typename Range, typename CompiledFormat>
+    friend auto cf::vformat_to(Range out, CompiledFormat &cf, basic_format_args<Context> args) ->
+        typename Context::iterator;
 
   public:
-    template <unsigned N> struct format_parts_array
+    compiled_format() = delete;
+    explicit constexpr compiled_format(basic_string_view<char_type> format_str)
+        : compiled_format_base<S>(format_str), format_str_(format_str)
     {
-      using value_type = format_part<char_type>;
-
-      FMT_CONSTEXPR format_parts_array() : arr{} {}
-
-      FMT_CONSTEXPR value_type &operator[](unsigned ind) { return arr[ind]; }
+    }
+  };
 
-      FMT_CONSTEXPR const value_type *begin() const { return arr; }
-      FMT_CONSTEXPR const value_type *end() const { return begin() + N; }
+#ifdef __cpp_if_constexpr
+  template <typename... Args> struct type_list
+  {
+  };
 
-    private:
-      value_type arr[N];
-    };
+  // Returns a reference to the argument at index N from [first, rest...].
+  template <int N, typename T, typename... Args>
+  constexpr const auto &get(const T &first, const Args &... rest)
+  {
+    static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+    if constexpr (N == 0)
+      return first;
+    else
+      return get<N - 1>(rest...);
+  }
 
-    struct empty
-    {
-      // Parts preparator will search for it
-      using value_type = format_part<char_type>;
-    };
+  template <int N, typename> struct get_type_impl;
 
-    using type = conditional_t<number_of_format_parts != 0,
-                               format_parts_array<number_of_format_parts>, empty>;
+  template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>>
+  {
+    using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
   };
 
-  template <typename Parts> class compiletime_prepared_parts_collector
+  template <int N, typename T> using get_type = typename get_type_impl<N, T>::type;
+
+  template <typename Char> struct text
   {
-  private:
-    using format_part = typename Parts::value_type;
+    basic_string_view<Char> data;
+    using char_type = Char;
 
-  public:
-    FMT_CONSTEXPR explicit compiletime_prepared_parts_collector(Parts &parts)
-        : parts_{parts}, counter_{0u}
+    template <typename OutputIt, typename... Args>
+    OutputIt format(OutputIt out, const Args &...) const
     {
+      // TODO: reserve
+      return copy_str<Char>(data.begin(), data.end(), out);
     }
+  };
 
-    FMT_CONSTEXPR void push_back(format_part part) { parts_[counter_++] = part; }
+  template <typename Char>
+  constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos, size_t size)
+  {
+    return {{&s[pos], size}};
+  }
 
-    FMT_CONSTEXPR format_part &back() { return parts_[counter_ - 1]; }
+  template <typename Char, typename OutputIt, typename T,
+            std::enable_if_t<std::is_integral_v<T>, int> = 0>
+  OutputIt format_default(OutputIt out, T value)
+  {
+    // TODO: reserve
+    format_int fi(value);
+    return std::copy(fi.data(), fi.data() + fi.size(), out);
+  }
 
-  private:
-    Parts &  parts_;
-    unsigned counter_;
-  };
+  template <typename Char, typename OutputIt> OutputIt format_default(OutputIt out, Char value)
+  {
+    *out++ = value;
+    return out;
+  }
 
-  template <typename PartsContainer, typename Char>
-  FMT_CONSTEXPR PartsContainer prepare_parts(basic_string_view<Char> format)
+  template <typename Char, typename OutputIt>
+  OutputIt format_default(OutputIt out, const Char *value)
   {
-    PartsContainer parts;
-    internal::parse_format_string</*IS_CONSTEXPR=*/false>(
-        format, format_preparation_handler<Char, PartsContainer>(format, parts));
-    return parts;
+    auto length = std::char_traits<Char>::length(value);
+    return copy_str<Char>(value, value + length, out);
   }
 
-  template <typename PartsContainer, typename Char>
-  FMT_CONSTEXPR PartsContainer prepare_compiletime_parts(basic_string_view<Char> format)
+  // A replacement field that refers to argument N.
+  template <typename Char, typename T, int N> struct field
   {
-    using collector = compiletime_prepared_parts_collector<PartsContainer>;
+    using char_type = Char;
 
-    PartsContainer parts;
-    collector      c(parts);
-    internal::parse_format_string</*IS_CONSTEXPR=*/true>(
-        format, format_preparation_handler<Char, collector>(format, c));
-    return parts;
-  }
+    template <typename OutputIt, typename... Args>
+    OutputIt format(OutputIt out, const Args &... args) const
+    {
+      // This ensures that the argument type is convertile to `const T&`.
+      const T &arg = get<N>(args...);
+      return format_default<Char>(out, arg);
+    }
+  };
 
-  template <typename PartsContainer> class runtime_parts_provider
+  template <typename L, typename R> struct concat
   {
-  public:
-    runtime_parts_provider() = delete;
-    template <typename Char>
-    runtime_parts_provider(basic_string_view<Char> format)
-        : parts_(prepare_parts<PartsContainer>(format))
+    L lhs;
+    R rhs;
+    using char_type = typename L::char_type;
+
+    template <typename OutputIt, typename... Args>
+    OutputIt format(OutputIt out, const Args &... args) const
     {
+      out = lhs.format(out, args...);
+      return rhs.format(out, args...);
     }
+  };
 
-    const PartsContainer &parts() const { return parts_; }
+  template <typename L, typename R> constexpr concat<L, R> make_concat(L lhs, R rhs)
+  {
+    return {lhs, rhs};
+  }
 
-  private:
-    PartsContainer parts_;
+  struct unknown_format
+  {
   };
 
-  template <typename Format, typename PartsContainer> struct compiletime_parts_provider
+  template <typename Char> constexpr size_t parse_text(basic_string_view<Char> str, size_t pos)
   {
-    compiletime_parts_provider() = delete;
-    template <typename Char> FMT_CONSTEXPR compiletime_parts_provider(basic_string_view<Char>) {}
+    for (size_t size = str.size(); pos != size; ++pos) {
+      if (str[pos] == '{' || str[pos] == '}')
+        break;
+    }
+    return pos;
+  }
 
-    const PartsContainer &parts() const
-    {
-      static FMT_CONSTEXPR_DECL const PartsContainer prepared_parts =
-          prepare_compiletime_parts<PartsContainer>(internal::to_string_view(Format{}));
+  template <typename Args, size_t POS, int ID, typename S>
+  constexpr auto compile_format_string(S format_str);
 
-      return prepared_parts;
+  template <typename Args, size_t POS, int ID, typename T, typename S>
+  constexpr auto parse_tail(T head, S format_str)
+  {
+    if constexpr (POS != to_string_view(format_str).size()) {
+      constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+      if constexpr (std::is_same<remove_cvref_t<decltype(tail)>, unknown_format>())
+        return tail;
+      else
+        return make_concat(head, tail);
     }
-  };
+    else {
+      return head;
+    }
+  }
+
+  // Compiles a non-empty format string and returns the compiled representation
+  // or unknown_format() on unrecognized input.
+  template <typename Args, size_t POS, int ID, typename S>
+  constexpr auto compile_format_string(S format_str)
+  {
+    using char_type                            = typename S::char_type;
+    constexpr basic_string_view<char_type> str = format_str;
+    if constexpr (str[POS] == '{') {
+      if (POS + 1 == str.size())
+        throw format_error("unmatched '{' in format string");
+      if constexpr (str[POS + 1] == '{') {
+        return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+      }
+      else if constexpr (str[POS + 1] == '}') {
+        using type = get_type<ID, Args>;
+        if constexpr (std::is_same<type, int>::value) {
+          return parse_tail<Args, POS + 2, ID + 1>(field<char_type, type, ID>(), format_str);
+        }
+        else {
+          return unknown_format();
+        }
+      }
+      else {
+        return unknown_format();
+      }
+    }
+    else if constexpr (str[POS] == '}') {
+      if (POS + 1 == str.size())
+        throw format_error("unmatched '}' in format string");
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    }
+    else {
+      constexpr auto end = parse_text(str, POS + 1);
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), format_str);
+    }
+  }
+#endif // __cpp_if_constexpr
 } // namespace internal
 
 #if FMT_USE_CONSTEXPR
+#ifdef __cpp_if_constexpr
 template <typename... Args, typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-FMT_CONSTEXPR auto compile(S format_str) -> internal::prepared_format<
-    S,
-    internal::compiletime_parts_provider<
-        S, typename internal::compiletime_prepared_parts_type_provider<S>::type>,
-    Args...>
+constexpr auto compile(S format_str)
 {
-  return format_str;
+  constexpr basic_string_view<typename S::char_type> str = format_str;
+  if constexpr (str.size() == 0) {
+    return internal::make_text(str, 0, 0);
+  }
+  else {
+    constexpr auto result =
+        internal::compile_format_string<internal::type_list<Args...>, 0, 0>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(result)>, internal::unknown_format>()) {
+      return internal::compiled_format<S, Args...>(to_string_view(format_str));
+    }
+    else {
+      return result;
+    }
+  }
 }
-#endif
 
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(!std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
+std::basic_string<Char> format(const CompiledFormat &cf, const Args &... args)
+{
+  basic_memory_buffer<Char> buffer;
+  using range   = buffer_range<Char>;
+  using context = buffer_context<Char>;
+  cf.format(std::back_inserter(buffer), args...);
+  return to_string(buffer);
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(!std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
+OutputIt format_to(OutputIt out, const CompiledFormat &cf, const Args &... args)
+{
+  return cf.format(out, args...);
+}
+#else
+template <typename... Args, typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto compile(S format_str) -> internal::compiled_format<S, Args...>
+{
+  return internal::compiled_format<S, Args...>(to_string_view(format_str));
+}
+#endif // __cpp_if_constexpr
+#endif // FMT_USE_CONSTEXPR
+
+// Compiles the format string which must be a string literal.
 template <typename... Args, typename Char, size_t N>
-auto compile(const Char (&format_str)[N]) -> internal::prepared_format<
-    std::basic_string<Char>,
-    internal::runtime_parts_provider<std::vector<internal::format_part<Char>>>, Args...>
+auto compile(const Char (&format_str)[N]) -> internal::compiled_format<const Char *, Args...>
 {
-  return std::basic_string<Char>(format_str, N - 1);
+  return internal::compiled_format<const Char *, Args...>(
+      basic_string_view<Char>(format_str, N - 1));
 }
 
 template <typename CompiledFormat, typename... Args,
-          typename Char = typename CompiledFormat::char_type>
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
 std::basic_string<Char> format(const CompiledFormat &cf, const Args &... args)
 {
   basic_memory_buffer<Char> buffer;
-  using range   = internal::buffer_range<Char>;
+  using range   = buffer_range<Char>;
   using context = buffer_context<Char>;
-  cf.template vformat_to<range, context>(range(buffer), {make_format_args<context>(args...)});
+  internal::cf::vformat_to<context>(range(buffer), cf, {make_format_args<context>(args...)});
   return to_string(buffer);
 }
 
-template <typename OutputIt, typename CompiledFormat, typename... Args>
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
 OutputIt format_to(OutputIt out, const CompiledFormat &cf, const Args &... args)
 {
   using char_type = typename CompiledFormat::char_type;
   using range     = internal::output_range<OutputIt, char_type>;
   using context   = format_context_t<OutputIt, char_type>;
-  return cf.template vformat_to<range, context>(range(out), {make_format_args<context>(args...)});
+  return internal::cf::vformat_to<context>(range(out), cf, {make_format_args<context>(args...)});
 }
 
 template <typename OutputIt, typename CompiledFormat, typename... Args,
@@ -484,9 +596,7 @@ format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, const CompiledF
 template <typename CompiledFormat, typename... Args>
 std::size_t formatted_size(const CompiledFormat &cf, const Args &... args)
 {
-  return fmt::format_to(internal::counting_iterator<typename CompiledFormat::char_type>(), cf,
-                        args...)
-      .count();
+  return format_to(internal::counting_iterator(), cf, args...).count();
 }
 
 FMT_END_NAMESPACE
diff --git a/packages/seacas/libraries/ioss/src/fmt/core.h b/packages/seacas/libraries/ioss/src/fmt/core.h
index 19a718cb788f..1a1ecfe1e83a 100644
--- a/packages/seacas/libraries/ioss/src/fmt/core.h
+++ b/packages/seacas/libraries/ioss/src/fmt/core.h
@@ -52,6 +52,12 @@
 #define FMT_HAS_GXX_CXX11 0
 #endif
 
+#ifdef __NVCC__
+#define FMT_NVCC __NVCC__
+#else
+#define FMT_NVCC 0
+#endif
+
 #ifdef _MSC_VER
 #define FMT_MSC_VER _MSC_VER
 #else
@@ -63,7 +69,8 @@
 #ifndef FMT_USE_CONSTEXPR
 #define FMT_USE_CONSTEXPR                                                                          \
   (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 ||                                \
-   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
+   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&                                          \
+      !FMT_NVCC
 #endif
 #if FMT_USE_CONSTEXPR
 #define FMT_CONSTEXPR constexpr
@@ -134,8 +141,8 @@
 #endif
 #endif
 
-// Workaround broken [[deprecated]] in the Intel compiler.
-#if defined(__INTEL_COMPILER) || defined(__NVCC__)
+// Workaround broken [[deprecated]] in the Intel compiler and NVCC.
+#if defined(__INTEL_COMPILER) || FMT_NVCC
 #define FMT_DEPRECATED_ALIAS
 #else
 #define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
@@ -203,6 +210,7 @@ template <bool B, class T, class F> using conditional_t = typename std::conditio
 template <bool B> using bool_constant                   = std::integral_constant<bool, B>;
 template <typename T> using remove_reference_t          = typename std::remove_reference<T>::type;
 template <typename T> using remove_const_t              = typename std::remove_const<T>::type;
+template <typename T> using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
 
 struct monostate
 {
@@ -231,7 +239,25 @@ namespace internal {
   };
 #endif
 
-  // Casts nonnegative integer to unsigned.
+#ifdef FMT_USE_INT128
+// Do nothing.
+#elif defined(__SIZEOF_INT128__)
+#define FMT_USE_INT128 1
+  using int128_t                                 = __int128_t;
+  using uint128_t                                = __uint128_t;
+#else
+#define FMT_USE_INT128 0
+#endif
+#if !FMT_USE_INT128
+  struct int128_t
+  {
+  };
+  struct uint128_t
+  {
+  };
+#endif
+
+  // Casts a nonnegative integer to unsigned.
   template <typename Int>
   FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value)
   {
@@ -296,6 +322,8 @@ template <typename Char> class basic_string_view
   FMT_CONSTEXPR iterator begin() const { return data_; }
   FMT_CONSTEXPR iterator end() const { return data_ + size_; }
 
+  FMT_CONSTEXPR const Char &operator[](size_t pos) const { return data_[pos]; }
+
   FMT_CONSTEXPR void remove_prefix(size_t n)
   {
     data_ += n;
@@ -681,10 +709,13 @@ namespace internal {
     uint_type,
     long_long_type,
     ulong_long_type,
+    int128_type,
+    uint128_type,
     bool_type,
     char_type,
     last_integer_type = char_type,
     // followed by floating-point types.
+    float_type,
     double_type,
     long_double_type,
     last_numeric_type = long_double_type,
@@ -711,21 +742,24 @@ namespace internal {
   FMT_TYPE_CONSTANT(unsigned, uint_type);
   FMT_TYPE_CONSTANT(long long, long_long_type);
   FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+  FMT_TYPE_CONSTANT(int128_t, int128_type);
+  FMT_TYPE_CONSTANT(uint128_t, uint128_type);
   FMT_TYPE_CONSTANT(bool, bool_type);
   FMT_TYPE_CONSTANT(Char, char_type);
+  FMT_TYPE_CONSTANT(float, float_type);
   FMT_TYPE_CONSTANT(double, double_type);
   FMT_TYPE_CONSTANT(long double, long_double_type);
   FMT_TYPE_CONSTANT(const Char *, cstring_type);
   FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
   FMT_TYPE_CONSTANT(const void *, pointer_type);
 
-  FMT_CONSTEXPR bool is_integral(type t)
+  FMT_CONSTEXPR bool is_integral_type(type t)
   {
     FMT_ASSERT(t != named_arg_type, "invalid argument type");
     return t > none_type && t <= last_integer_type;
   }
 
-  FMT_CONSTEXPR bool is_arithmetic(type t)
+  FMT_CONSTEXPR bool is_arithmetic_type(type t)
   {
     FMT_ASSERT(t != named_arg_type, "invalid argument type");
     return t > none_type && t <= last_numeric_type;
@@ -755,8 +789,11 @@ namespace internal {
       unsigned                         uint_value;
       long long                        long_long_value;
       unsigned long long               ulong_long_value;
+      int128_t                         int128_value;
+      uint128_t                        uint128_value;
       bool                             bool_value;
       char_type                        char_value;
+      float                            float_value;
       double                           double_value;
       long double                      long_double_value;
       const void *                     pointer;
@@ -769,6 +806,9 @@ namespace internal {
     FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
     value(long long val) : long_long_value(val) {}
     value(unsigned long long val) : ulong_long_value(val) {}
+    value(int128_t val) : int128_value(val) {}
+    value(uint128_t val) : uint128_value(val) {}
+    value(float val) : float_value(val) {}
     value(double val) : double_value(val) {}
     value(long double val) : long_double_value(val) {}
     value(bool val) : bool_value(val) {}
@@ -821,16 +861,18 @@ namespace internal {
   {
     using char_type = typename Context::char_type;
 
-    FMT_CONSTEXPR int      map(signed char val) { return val; }
-    FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
-    FMT_CONSTEXPR int      map(short val) { return val; }
-    FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
-    FMT_CONSTEXPR int      map(int val) { return val; }
-    FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
-    FMT_CONSTEXPR long_type map(long val) { return val; }
+    FMT_CONSTEXPR int                map(signed char val) { return val; }
+    FMT_CONSTEXPR unsigned           map(unsigned char val) { return val; }
+    FMT_CONSTEXPR int                map(short val) { return val; }
+    FMT_CONSTEXPR unsigned           map(unsigned short val) { return val; }
+    FMT_CONSTEXPR int                map(int val) { return val; }
+    FMT_CONSTEXPR unsigned           map(unsigned val) { return val; }
+    FMT_CONSTEXPR long_type          map(long val) { return val; }
     FMT_CONSTEXPR ulong_type         map(unsigned long val) { return val; }
     FMT_CONSTEXPR long long          map(long long val) { return val; }
     FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
+    FMT_CONSTEXPR int128_t           map(int128_t val) { return val; }
+    FMT_CONSTEXPR uint128_t          map(uint128_t val) { return val; }
     FMT_CONSTEXPR bool               map(bool val) { return val; }
 
     template <typename T, FMT_ENABLE_IF(is_char<T>::value)> FMT_CONSTEXPR char_type map(T val)
@@ -840,7 +882,7 @@ namespace internal {
       return val;
     }
 
-    FMT_CONSTEXPR double      map(float val) { return static_cast<double>(val); }
+    FMT_CONSTEXPR float       map(float val) { return val; }
     FMT_CONSTEXPR double      map(double val) { return val; }
     FMT_CONSTEXPR long double map(long double val) { return val; }
 
@@ -860,6 +902,14 @@ namespace internal {
     {
       return basic_string_view<char_type>(val);
     }
+    template <typename T,
+              FMT_ENABLE_IF(std::is_constructible<std_string_view<char_type>, T>::value &&
+                            !std::is_constructible<basic_string_view<char_type>, T>::value &&
+                            !is_string<T>::value)>
+    FMT_CONSTEXPR basic_string_view<char_type> map(const T &val)
+    {
+      return std_string_view<char_type>(val);
+    }
     FMT_CONSTEXPR const char *map(const signed char *val)
     {
       static_assert(std::is_same<char_type, char>::value, "invalid string type");
@@ -887,9 +937,10 @@ namespace internal {
     template <typename T,
               FMT_ENABLE_IF(std::is_enum<T>::value && !has_formatter<T, Context>::value &&
                             !has_fallback_formatter<T, Context>::value)>
-    FMT_CONSTEXPR int map(const T &val)
+    FMT_CONSTEXPR auto map(const T &val)
+        -> decltype(map(static_cast<typename std::underlying_type<T>::type>(val)))
     {
-      return static_cast<int>(val);
+      return map(static_cast<typename std::underlying_type<T>::type>(val));
     }
     template <typename T, FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
                                         (has_formatter<T, Context>::value ||
@@ -913,8 +964,9 @@ namespace internal {
   using mapped_type_constant = type_constant<decltype(arg_mapper<Context>().map(std::declval<T>())),
                                              typename Context::char_type>;
 
+  enum { packed_arg_bits = 5 };
   // Maximum number of arguments with packed types.
-  enum { max_packed_args = 15 };
+  enum { max_packed_args = 63 / packed_arg_bits };
   enum : unsigned long long { is_unpacked_bit = 1ull << 63 };
 
   template <typename Context> class arg_map;
@@ -961,8 +1013,8 @@ template <typename Context> class basic_format_arg
 
   internal::type type() const { return type_; }
 
-  bool is_integral() const { return internal::is_integral(type_); }
-  bool is_arithmetic() const { return internal::is_arithmetic(type_); }
+  bool is_integral() const { return internal::is_integral_type(type_); }
+  bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
 };
 
 /**
@@ -984,8 +1036,16 @@ FMT_CONSTEXPR auto visit_format_arg(Visitor &&vis, const basic_format_arg<Contex
   case internal::uint_type: return vis(arg.value_.uint_value);
   case internal::long_long_type: return vis(arg.value_.long_long_value);
   case internal::ulong_long_type: return vis(arg.value_.ulong_long_value);
+#if FMT_USE_INT128
+  case internal::int128_type: return vis(arg.value_.int128_value);
+  case internal::uint128_type: return vis(arg.value_.uint128_value);
+#else
+  case internal::int128_type:
+  case internal::uint128_type: break;
+#endif
   case internal::bool_type: return vis(arg.value_.bool_value);
   case internal::char_type: return vis(arg.value_.char_value);
+  case internal::float_type: return vis(arg.value_.float_value);
   case internal::double_type: return vis(arg.value_.double_value);
   case internal::long_double_type: return vis(arg.value_.long_double_value);
   case internal::cstring_type: return vis(arg.value_.string.data);
@@ -1058,7 +1118,8 @@ namespace internal {
   template <typename Context, typename Arg, typename... Args>
   constexpr unsigned long long encode_types()
   {
-    return mapped_type_constant<Arg, Context>::value | (encode_types<Context, Args...>() << 4);
+    return mapped_type_constant<Arg, Context>::value |
+           (encode_types<Context, Args...>() << packed_arg_bits);
   }
 
   template <typename Context, typename T>
@@ -1108,9 +1169,9 @@ template <typename OutputIt, typename Char> class basic_format_context
    Constructs a ``basic_format_context`` object. References to the arguments are
    stored in the object so make sure they have appropriate lifetimes.
    */
-  basic_format_context(OutputIt out_it, basic_format_args<basic_format_context> ctx_args,
+  basic_format_context(OutputIt out, basic_format_args<basic_format_context> ctx_args,
                        internal::locale_ref loc = internal::locale_ref())
-      : out_(out_it), args_(ctx_args), loc_(loc)
+      : out_(out), args_(ctx_args), loc_(loc)
   {
   }
 
@@ -1205,8 +1266,9 @@ template <typename Context> class basic_format_args
 
   internal::type type(int index) const
   {
-    int shift = index * 4;
-    return static_cast<internal::type>((types_ & (0xfull << shift)) >> shift);
+    int shift = index * internal::packed_arg_bits;
+    int mask  = (1 << internal::packed_arg_bits) - 1;
+    return static_cast<internal::type>((types_ >> shift) & mask);
   }
 
   friend class internal::arg_map<Context>;
@@ -1364,11 +1426,9 @@ namespace internal {
   inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
   make_args_checked(const S &format_str, const remove_reference_t<Args> &... args)
   {
-#ifndef __INTEL_COMPILER
     static_assert(all_true<(!std::is_base_of<view, remove_reference_t<Args>>() ||
                             !std::is_reference<Args>())...>::value,
                   "passing views as lvalues is disallowed");
-#endif
     check_format_string<remove_const_t<remove_reference_t<Args>>...>(format_str);
     return {args...};
   }
diff --git a/packages/seacas/libraries/ioss/src/fmt/format-inl.h b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
index 147062fe5d38..283d6912e12f 100644
--- a/packages/seacas/libraries/ioss/src/fmt/format-inl.h
+++ b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
@@ -17,49 +17,43 @@
 #include <climits>
 #include <cmath>
 #include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
-#include <cstring>  // for std::memmove
+#include <cstring> // for std::memmove
 #include <cwchar>
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-#  include <locale>
+#include <locale>
 #endif
 
 #if FMT_USE_WINDOWS_H
-#  if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#    include <windows.h>
-#  else
-#    define NOMINMAX
-#    include <windows.h>
-#    undef NOMINMAX
-#  endif
+#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
+#include <windows.h>
+#else
+#define NOMINMAX
+#include <windows.h>
+#undef NOMINMAX
+#endif
 #endif
 
 #if FMT_EXCEPTIONS
-#  define FMT_TRY try
-#  define FMT_CATCH(x) catch (x)
+#define FMT_TRY try
+#define FMT_CATCH(x) catch (x)
 #else
-#  define FMT_TRY if (true)
-#  define FMT_CATCH(x) if (false)
+#define FMT_TRY if (true)
+#define FMT_CATCH(x) if (false)
 #endif
 
 #ifdef _MSC_VER
-#  pragma warning(push)
-#  pragma warning(disable : 4127)  // conditional expression is constant
-#  pragma warning(disable : 4702)  // unreachable code
-// Disable deprecation warning for strerror. The latter is not called but
-// MSVC fails to detect it.
-#  pragma warning(disable : 4996)
+#pragma warning(push)
+#pragma warning(disable : 4702) // unreachable code
 #endif
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
-inline fmt::internal::null<> strerror_r(int, char*, ...) {
-  return fmt::internal::null<>();
-}
-inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) {
+inline fmt::internal::null<> strerror_r(int, char *, ...) { return fmt::internal::null<>(); }
+inline fmt::internal::null<> strerror_s(char *, std::size_t, ...)
+{
   return fmt::internal::null<>();
 }
 
@@ -67,773 +61,1203 @@ FMT_BEGIN_NAMESPACE
 namespace internal {
 
 #ifndef _MSC_VER
-#  define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-#  define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-using format_func = void (*)(internal::buffer<char>&, int, string_view);
-
-// Portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-FMT_FUNC int safe_strerror(int error_code, char*& buffer,
-                           std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
-
-  class dispatcher {
-   private:
-    int error_code_;
-    char*& buffer_;
-    std::size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher&) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    int handle(char* message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
+#define FMT_SNPRINTF snprintf
+#else // _MSC_VER
+  inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...)
+  {
+    va_list args;
+    va_start(args, format);
+    int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
+    va_end(args);
+    return result;
+  }
+#define FMT_SNPRINTF fmt_snprintf
+#endif // _MSC_VER
+
+  using format_func = void (*)(internal::buffer<char> &, int, string_view);
+
+  // A portable thread-safe version of strerror.
+  // Sets buffer to point to a string describing the error code.
+  // This can be either a pointer to a string stored in buffer,
+  // or a pointer to some static immutable string.
+  // Returns one of the following values:
+  //   0      - success
+  //   ERANGE - buffer is not large enough to store the error message
+  //   other  - failure
+  // Buffer should be at least of size 1.
+  FMT_FUNC int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT
+  {
+    FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
+
+    class dispatcher
+    {
+    private:
+      int         error_code_;
+      char *&     buffer_;
+      std::size_t buffer_size_;
+
+      // A noop assignment operator to avoid bogus warnings.
+      void operator=(const dispatcher &) {}
+
+      // Handle the result of XSI-compliant version of strerror_r.
+      int handle(int result)
+      {
+        // glibc versions before 2.13 return result in errno.
+        return result == -1 ? errno : result;
+      }
 
-    // Handle the case when strerror_r is not available.
-    int handle(internal::null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
+      // Handle the result of GNU-specific version of strerror_r.
+      int handle(char *message)
+      {
+        // If the buffer is full then the message is probably truncated.
+        if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
+          return ERANGE;
+        buffer_ = message;
+        return 0;
+      }
 
-    // Fallback to strerror_s when strerror_r is not available.
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
-                                                                : result;
-    }
+      // Handle the case when strerror_r is not available.
+      int handle(internal::null<>)
+      {
+        return fallback(strerror_s(buffer_, buffer_size_, error_code_));
+      }
+
+      // Fallback to strerror_s when strerror_r is not available.
+      int fallback(int result)
+      {
+        // If the buffer is full then the message is probably truncated.
+        return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE : result;
+      }
 
 #if !FMT_MSC_VER
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(internal::null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
+      // Fallback to strerror if strerror_r and strerror_s are not available.
+      int fallback(internal::null<>)
+      {
+        errno   = 0;
+        buffer_ = strerror(error_code_);
+        return errno;
+      }
 #endif
 
-   public:
-    dispatcher(int err_code, char*& buf, std::size_t buf_size)
-        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
-}
+    public:
+      dispatcher(int err_code, char *&buf, std::size_t buf_size)
+          : error_code_(err_code), buffer_(buf), buffer_size_(buf_size)
+      {
+      }
 
-FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
-                                string_view message) FMT_NOEXCEPT {
-  // Report error code making sure that the output fits into
-  // inline_buffer_size to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.resize(0);
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  auto abs_value = static_cast<uint32_or_64_t<int>>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
+      int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
+    };
+    return dispatcher(error_code, buffer, buffer_size).run();
   }
-  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
-  internal::writer w(out);
-  if (message.size() <= inline_buffer_size - error_code_size) {
-    w.write(message);
-    w.write(SEP);
+
+  FMT_FUNC void format_error_code(internal::buffer<char> &out, int error_code,
+                                  string_view message) FMT_NOEXCEPT
+  {
+    // Report error code making sure that the output fits into
+    // inline_buffer_size to avoid dynamic memory allocation and potential
+    // bad_alloc.
+    out.resize(0);
+    static const char SEP[]       = ": ";
+    static const char ERROR_STR[] = "error ";
+    // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+    std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+    auto        abs_value       = static_cast<uint32_or_64_or_128_t<int>>(error_code);
+    if (internal::is_negative(error_code)) {
+      abs_value = 0 - abs_value;
+      ++error_code_size;
+    }
+    error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
+    internal::writer w(out);
+    if (message.size() <= inline_buffer_size - error_code_size) {
+      w.write(message);
+      w.write(SEP);
+    }
+    w.write(ERROR_STR);
+    w.write(error_code);
+    assert(out.size() <= inline_buffer_size);
   }
-  w.write(ERROR_STR);
-  w.write(error_code);
-  assert(out.size() <= inline_buffer_size);
-}
 
-// A wrapper around fwrite that throws on error.
-FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
-                           FILE* stream) {
-  size_t written = std::fwrite(ptr, size, count, stream);
-  if (written < count) {
-    FMT_THROW(system_error(errno, "cannot write to file"));
+  // A wrapper around fwrite that throws on error.
+  FMT_FUNC void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
+  {
+    size_t written = std::fwrite(ptr, size, count, stream);
+    if (written < count) {
+      FMT_THROW(system_error(errno, "cannot write to file"));
+    }
   }
-}
 
-FMT_FUNC void report_error(format_func func, int error_code,
-                           string_view message) FMT_NOEXCEPT {
-  memory_buffer full_message;
-  func(full_message, error_code, message);
-  // Don't use fwrite_fully because the latter may throw.
-  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
-}
-}  // namespace internal
+  FMT_FUNC void report_error(format_func func, int error_code, string_view message) FMT_NOEXCEPT
+  {
+    memory_buffer full_message;
+    func(full_message, error_code, message);
+    // Don't use fwrite_fully because the latter may throw.
+    (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
+    std::fputc('\n', stderr);
+  }
+} // namespace internal
 
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
 namespace internal {
 
-template <typename Locale>
-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
+  template <typename Locale> locale_ref::locale_ref(const Locale &loc) : locale_(&loc)
+  {
+    static_assert(std::is_same<Locale, std::locale>::value, "");
+  }
 
-template <typename Locale> Locale locale_ref::get() const {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
+  template <typename Locale> Locale locale_ref::get() const
+  {
+    static_assert(std::is_same<Locale, std::locale>::value, "");
+    return locale_ ? *static_cast<const std::locale *>(locale_) : std::locale();
+  }
 
-template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .thousands_sep();
-}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
-}
-}  // namespace internal
+  template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc)
+  {
+    return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).thousands_sep();
+  }
+  template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc)
+  {
+    return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).decimal_point();
+  }
+} // namespace internal
 #else
-template <typename Char>
-FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
+template <typename Char> FMT_FUNC Char internal::thousands_sep_impl(locale_ref)
+{
   return FMT_STATIC_THOUSANDS_SEPARATOR;
 }
-template <typename Char>
-FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
-  return '.';
-}
+template <typename Char> FMT_FUNC Char internal::decimal_point_impl(locale_ref) { return '.'; }
 #endif
 
 FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT {}
 FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT {}
 
-FMT_FUNC void system_error::init(int err_code, string_view format_str,
-                                 format_args args) {
+FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args)
+{
   error_code_ = err_code;
   memory_buffer buffer;
   format_system_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error& base = *this;
-  base = std::runtime_error(to_string(buffer));
+  std::runtime_error &base = *this;
+  base                     = std::runtime_error(to_string(buffer));
 }
 
 namespace internal {
 
-template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
-  // Assume little endian; pointer formatting is implementation-defined anyway.
-  int i = static_cast<int>(sizeof(void*)) - 1;
-  while (i > 0 && n.value[i] == 0) --i;
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
-}
+  template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n)
+  {
+    // Assume little endian; pointer formatting is implementation-defined anyway.
+    int i = static_cast<int>(sizeof(void *)) - 1;
+    while (i > 0 && n.value[i] == 0)
+      --i;
+    auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+    return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
+  }
 
-template <typename T>
-int format_float(char* buf, std::size_t size, const char* format, int precision,
-                 T value) {
+  template <typename T>
+  int format_float(char *buf, std::size_t size, const char *format, int precision, T value)
+  {
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (precision > 100000)
-    throw std::runtime_error(
-        "fuzz mode - avoid large allocation inside snprintf");
+    if (precision > 100000)
+      throw std::runtime_error("fuzz mode - avoid large allocation inside snprintf");
 #endif
-  // Suppress the warning about nonliteral format string.
-  auto snprintf_ptr = FMT_SNPRINTF;
-  return precision < 0 ? snprintf_ptr(buf, size, format, value)
-                       : snprintf_ptr(buf, size, format, precision, value);
-}
+    // Suppress the warning about nonliteral format string.
+    auto snprintf_ptr = FMT_SNPRINTF;
+    return precision < 0 ? snprintf_ptr(buf, size, format, value)
+                         : snprintf_ptr(buf, size, format, precision, value);
+  }
 
-template <typename T>
-const char basic_data<T>::digits[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-template <typename T>
-const char basic_data<T>::hex_digits[] = "0123456789abcdef";
-
-#define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, \
-      factor * 1000000, factor * 10000000, factor * 100000000,               \
-      factor * 1000000000
-
-template <typename T>
-const uint64_t basic_data<T>::powers_of_10_64[] = {
-    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
-    10000000000000000000ull};
-
-template <typename T>
-const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
-                                                           FMT_POWERS_OF_10(1)};
-
-template <typename T>
-const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
-    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
-    10000000000000000000ull};
-
-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-// These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::pow10_significands[] = {
-    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-};
+  template <typename T>
+  const char basic_data<T>::digits[] = "0001020304050607080910111213141516171819"
+                                       "2021222324252627282930313233343536373839"
+                                       "4041424344454647484950515253545556575859"
+                                       "6061626364656667686970717273747576777879"
+                                       "8081828384858687888990919293949596979899";
+
+  template <typename T> const char basic_data<T>::hex_digits[] = "0123456789abcdef";
+
+#define FMT_POWERS_OF_10(factor)                                                                   \
+  factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, factor * 1000000,     \
+      factor * 10000000, factor * 100000000, factor * 1000000000
+
+  template <typename T>
+  const uint64_t basic_data<T>::powers_of_10_64[] = {
+      1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
+
+  template <typename T>
+  const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0, FMT_POWERS_OF_10(1)};
+
+  template <typename T>
+  const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
+      0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
+
+  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+  // These are generated by support/compute-powers.py.
+  template <typename T>
+  const uint64_t basic_data<T>::pow10_significands[] = {
+      0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
+      0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f,
+      0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+      0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
+      0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5,
+      0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+      0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
+      0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd,
+      0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+      0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
+      0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c,
+      0x9c40000000000000, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+      0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
+      0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a,
+      0x924d692ca61be758, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+      0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+      0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece,
+      0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+      0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+      0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429,
+      0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+      0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
+  };
 
-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-// to significands above.
-template <typename T>
-const int16_t basic_data<T>::pow10_exponents[] = {
-    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
-    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
-    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
-    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-
-template <typename T>
-const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
-template <typename T>
-const char basic_data<T>::background_color[] = "\x1b[48;2;";
-template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
-
-template <typename T> struct bits {
-  static FMT_CONSTEXPR_DECL const int value =
-      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
-};
+  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+  // to significands above.
+  template <typename T>
+  const int16_t basic_data<T>::pow10_exponents[] = {
+      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
+      -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,  -635, -608, -582, -555,
+      -529,  -502,  -475,  -449,  -422,  -396,  -369,  -343,  -316,  -289, -263, -236, -210,
+      -183,  -157,  -130,  -103,  -77,   -50,   -24,   3,     30,    56,   83,   109,  136,
+      162,   189,   216,   242,   269,   295,   322,   348,   375,   402,  428,  455,  481,
+      508,   534,   561,   588,   614,   641,   667,   694,   720,   747,  774,  800,  827,
+      853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
+
+  template <typename T> const char    basic_data<T>::foreground_color[] = "\x1b[38;2;";
+  template <typename T> const char    basic_data<T>::background_color[] = "\x1b[48;2;";
+  template <typename T> const char    basic_data<T>::reset_color[]      = "\x1b[0m";
+  template <typename T> const wchar_t basic_data<T>::wreset_color[]     = L"\x1b[0m";
+  template <typename T> const char    basic_data<T>::signs[]            = {0, '-', '+', ' '};
+
+  template <typename T> struct bits
+  {
+    static FMT_CONSTEXPR_DECL const int value =
+        static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
+  };
 
-// A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  using significand_type = uint64_t;
-
-  // All sizes are in bits.
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-      std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-      1ull << double_significand_size;
-
- public:
-  significand_type f;
-  int e;
-
-  static FMT_CONSTEXPR_DECL const int significand_size =
-      bits<significand_type>::value;
-
-  fp() : f(0), e(0) {}
-  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double> explicit fp(Double d) {
-    // Assume double is in the format [sign][exponent][significand].
-    using limits = std::numeric_limits<Double>;
-    const int exponent_size =
-        bits<Double>::value - double_significand_size - 1;  // -1 for sign
-    const uint64_t significand_mask = implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-    auto u = bit_cast<uint64_t>(d);
-    auto biased_e = (u & exponent_mask) >> double_significand_size;
-    f = u & significand_mask;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-  }
+  class fp;
+  template <int SHIFT = 0> fp normalize(fp value);
+
+  // A handmade floating-point number f * pow(2, e).
+  class fp
+  {
+  private:
+    using significand_type = uint64_t;
+
+    // All sizes are in bits.
+    // Subtract 1 to account for an implicit most significant bit in the
+    // normalized form.
+    static FMT_CONSTEXPR_DECL const int double_significand_size =
+        std::numeric_limits<double>::digits - 1;
+    static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size;
+
+  public:
+    significand_type f;
+    int              e;
+
+    static FMT_CONSTEXPR_DECL const int significand_size = bits<significand_type>::value;
+
+    fp() : f(0), e(0) {}
+    fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
+
+    // Constructs fp from an IEEE754 double. It is a template to prevent compile
+    // errors on platforms where double is not IEEE754.
+    template <typename Double> explicit fp(Double d) { assign(d); }
+
+    // Normalizes the value converted from double and multiplied by (1 << SHIFT).
+    template <int SHIFT> friend fp normalize(fp value)
+    {
+      // Handle subnormals.
+      const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
+      while ((value.f & shifted_implicit_bit) == 0) {
+        value.f <<= 1;
+        --value.e;
+      }
+      // Subtract 1 to account for hidden bit.
+      const auto offset = fp::significand_size - fp::double_significand_size - SHIFT - 1;
+      value.f <<= offset;
+      value.e -= offset;
+      return value;
+    }
 
-  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-  template <int SHIFT = 0> void normalize() {
-    // Handle subnormals.
-    auto shifted_implicit_bit = implicit_bit << SHIFT;
-    while ((f & shifted_implicit_bit) == 0) {
-      f <<= 1;
-      --e;
-    }
-    // Subtract 1 to account for hidden bit.
-    auto offset = significand_size - double_significand_size - SHIFT - 1;
-    f <<= offset;
-    e -= offset;
-  }
+    // Assigns d to this and return true iff predecessor is closer than successor.
+    template <typename Double> bool assign(Double d)
+    {
+      // Assume double is in the format [sign][exponent][significand].
+      using limits            = std::numeric_limits<Double>;
+      const int exponent_size = bits<Double>::value - double_significand_size - 1; // -1 for sign
+      const uint64_t significand_mask = implicit_bit - 1;
+      const uint64_t exponent_mask    = (~0ull >> 1) & ~significand_mask;
+      const int      exponent_bias    = (1 << exponent_size) - limits::max_exponent - 1;
+      auto           u                = bit_cast<uint64_t>(d);
+      f                               = u & significand_mask;
+      auto biased_e                   = (u & exponent_mask) >> double_significand_size;
+      // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
+      // the smallest normalized number (biased_e > 1).
+      bool is_predecessor_closer = f == 0 && biased_e > 1;
+      if (biased_e != 0)
+        f += implicit_bit;
+      else
+        biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
+      e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
+      return is_predecessor_closer;
+    }
 
-  // Compute lower and upper boundaries (m^- and m^+ in the Grisu paper), where
-  // a boundary is a value half way between the number and its predecessor
-  // (lower) or successor (upper). The upper boundary is normalized and lower
-  // has the same exponent but may be not normalized.
-  void compute_boundaries(fp& lower, fp& upper) const {
-    lower =
-        f == implicit_bit ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
-    upper = fp((f << 1) + 1, e - 1);
-    upper.normalize<1>();  // 1 is to account for the exponent shift above.
-    lower.f <<= lower.e - upper.e;
-    lower.e = upper.e;
-  }
-};
+    // Assigns d to this together with computing lower and upper boundaries,
+    // where a boundary is a value half way between the number and its predecessor
+    // (lower) or successor (upper). The upper boundary is normalized and lower
+    // has the same exponent but may be not normalized.
+    template <typename Double> void assign_with_boundaries(Double d, fp &lower, fp &upper)
+    {
+      bool is_lower_closer = assign(d);
+      lower                = is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
+      // 1 in normalize accounts for the exponent shift above.
+      upper = normalize<1>(fp((f << 1) + 1, e - 1));
+      lower.f <<= lower.e - upper.e;
+      lower.e = upper.e;
+    }
 
-// Returns an fp number representing x - y. Result may not be normalized.
-inline fp operator-(fp x, fp y) {
-  FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
-  return fp(x.f - y.f, x.e);
-}
+    template <typename Double> void assign_float_with_boundaries(Double d, fp &lower, fp &upper)
+    {
+      assign(d);
+      constexpr int min_normal_e =
+          std::numeric_limits<float>::min_exponent - std::numeric_limits<double>::digits;
+      significand_type half_ulp =
+          1 << (std::numeric_limits<double>::digits - std::numeric_limits<float>::digits - 1);
+      if (min_normal_e > e)
+        half_ulp <<= min_normal_e - e;
+      upper = normalize<0>(fp(f + half_ulp, e));
+      lower = fp(f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
+      lower.f <<= lower.e - upper.e;
+      lower.e = upper.e;
+    }
+  };
+
+  inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
 
-// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
-// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be
-// normalized.
-FMT_FUNC fp operator*(fp x, fp y) {
-  int exp = x.e + y.e + 64;
+  // Returns an fp number representing x - y. Result may not be normalized.
+  inline fp operator-(fp x, fp y)
+  {
+    FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
+    return fp(x.f - y.f, x.e);
+  }
+
+  // Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
+  // with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be
+  // normalized.
+  FMT_FUNC fp operator*(fp x, fp y)
+  {
+    int exp = x.e + y.e + 64;
 #if FMT_USE_INT128
-  auto product = static_cast<__uint128_t>(x.f) * y.f;
-  auto f = static_cast<uint64_t>(product >> 64);
-  if ((static_cast<uint64_t>(product) & (1ULL << 63)) != 0) ++f;
-  return fp(f, exp);
+    auto product = static_cast<__uint128_t>(x.f) * y.f;
+    auto f       = static_cast<uint64_t>(product >> 64);
+    if ((static_cast<uint64_t>(product) & (1ULL << 63)) != 0)
+      ++f;
+    return fp(f, exp);
 #else
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = x.f >> 32, b = x.f & mask;
-  uint64_t c = y.f >> 32, d = y.f & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), exp);
+    // Multiply 32-bit parts of significands.
+    uint64_t mask = (1ULL << 32) - 1;
+    uint64_t a = x.f >> 32, b = x.f & mask;
+    uint64_t c = y.f >> 32, d = y.f & mask;
+    uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+    // Compute mid 64-bit of result and round.
+    uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+    return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), exp);
 #endif
-}
-
-// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its
-// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 28.
-FMT_FUNC fp get_cached_power(int min_exponent, int& pow10_exponent) {
-  const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
-  int index = static_cast<int>(
-      std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between 2 consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return fp(data::pow10_significands[index], data::pow10_exponents[index]);
-}
+  }
 
-enum round_direction { unknown, up, down };
-
-// Given the divisor (normally a power of 10), the remainder = v % divisor for
-// some number v and the error, returns whether v should be rounded up, down, or
-// whether the rounding direction can't be determined due to error.
-// error should be less than divisor / 2.
-inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
-                                           uint64_t error) {
-  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
-  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
-  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
-  // Round down if (remainder + error) * 2 <= divisor.
-  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
-    return down;
-  // Round up if (remainder - error) * 2 >= divisor.
-  if (remainder >= error &&
-      remainder - error >= divisor - (remainder - error)) {
-    return up;
+  // Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
+  // (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
+  FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent)
+  {
+    const uint64_t one_over_log2_10 = 0x4d104d42; // round(pow(2, 32) / log2(10))
+    int            index            = static_cast<int>(
+        static_cast<int64_t>((min_exponent + fp::significand_size - 1) * one_over_log2_10 +
+                             ((uint64_t(1) << 32) - 1) // ceil
+                             ) >>
+        32 // arithmetic shift
+    );
+    // Decimal exponent of the first (smallest) cached power of 10.
+    const int first_dec_exp = -348;
+    // Difference between 2 consecutive decimal exponents in cached powers of 10.
+    const int dec_exp_step = 8;
+    index                  = (index - first_dec_exp - 1) / dec_exp_step + 1;
+    pow10_exponent         = first_dec_exp + index * dec_exp_step;
+    return fp(data::pow10_significands[index], data::pow10_exponents[index]);
   }
-  return unknown;
-}
 
-namespace digits {
-enum result {
-  more,  // Generate more digits.
-  done,  // Done generating digits.
-  error  // Digit generation cancelled due to an error.
-};
-}
+  // A simple accumulator to hold the sums of terms in bigint::square if uint128_t
+  // is not available.
+  struct accumulator
+  {
+    uint64_t lower;
+    uint64_t upper;
+
+    accumulator() : lower(0), upper(0) {}
+    explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
+
+    void operator+=(uint64_t n)
+    {
+      lower += n;
+      if (lower < n)
+        ++upper;
+    }
+    void operator>>=(int shift)
+    {
+      assert(shift == 32);
+      (void)shift;
+      lower = (upper << 32) | (lower >> 32);
+      upper >>= 32;
+    }
+  };
 
-// Generates output using the Grisu digit-gen algorithm.
-// error: the size of the region (lower, upper) outside of which numbers
-// definitely do not round to value (Delta in Grisu3).
-template <typename Handler>
-digits::result grisu_gen_digits(fp value, uint64_t error, int& exp,
-                                Handler& handler) {
-  fp one(1ull << -value.e, value.e);
-  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
-  // zero because it contains a product of two 64-bit numbers with MSB set (due
-  // to normalization) - 1, shifted right by at most 60 bits.
-  uint32_t integral = static_cast<uint32_t>(value.f >> -one.e);
-  FMT_ASSERT(integral != 0, "");
-  FMT_ASSERT(integral == value.f >> -one.e, "");
-  // The fractional part of scaled value (p2 in Grisu) c = value % one.
-  uint64_t fractional = value.f & (one.f - 1);
-  exp = count_digits(integral);  // kappa in Grisu.
-  // Divide by 10 to prevent overflow.
-  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
-                                 value.f / 10, error * 10, exp);
-  if (result != digits::more) return result;
-  // Generate digits for the integral part. This can produce up to 10 digits.
-  do {
-    uint32_t digit = 0;
-    // This optimization by miloyip reduces the number of integer divisions by
-    // one per iteration.
-    switch (exp) {
-    case 10:
-      digit = integral / 1000000000;
-      integral %= 1000000000;
-      break;
-    case 9:
-      digit = integral / 100000000;
-      integral %= 100000000;
-      break;
-    case 8:
-      digit = integral / 10000000;
-      integral %= 10000000;
-      break;
-    case 7:
-      digit = integral / 1000000;
-      integral %= 1000000;
-      break;
-    case 6:
-      digit = integral / 100000;
-      integral %= 100000;
-      break;
-    case 5:
-      digit = integral / 10000;
-      integral %= 10000;
-      break;
-    case 4:
-      digit = integral / 1000;
-      integral %= 1000;
-      break;
-    case 3:
-      digit = integral / 100;
-      integral %= 100;
-      break;
-    case 2:
-      digit = integral / 10;
-      integral %= 10;
-      break;
-    case 1:
-      digit = integral;
-      integral = 0;
-      break;
-    default:
-      FMT_ASSERT(false, "invalid number of digits");
-    }
-    --exp;
-    uint64_t remainder =
-        (static_cast<uint64_t>(integral) << -one.e) + fractional;
-    result = handler.on_digit(static_cast<char>('0' + digit),
-                              data::powers_of_10_64[exp] << -one.e, remainder,
-                              error, exp, true);
-    if (result != digits::more) return result;
-  } while (exp > 0);
-  // Generate digits for the fractional part.
-  for (;;) {
-    fractional *= 10;
-    error *= 10;
-    char digit =
-        static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
-    fractional &= one.f - 1;
-    --exp;
-    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
-    if (result != digits::more) return result;
-  }
-}
+  class bigint
+  {
+  private:
+    // A bigint is stored as an array of bigits (big digits), with bigit at index
+    // 0 being the least significant one.
+    using bigit        = uint32_t;
+    using double_bigit = uint64_t;
+    enum { bigits_capacity = 32 };
+    basic_memory_buffer<bigit, bigits_capacity> bigits_;
+    int                                         exp_;
+
+    static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
+
+    friend struct formatter<bigint>;
+
+    void subtract_bigits(int index, bigit other, bigit &borrow)
+    {
+      auto result    = static_cast<double_bigit>(bigits_[index]) - other - borrow;
+      bigits_[index] = static_cast<bigit>(result);
+      borrow         = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
+    }
 
-// The fixed precision digit handler.
-struct fixed_handler {
-  char* buf;
-  int size;
-  int precision;
-  int exp10;
-  bool fixed;
-
-  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
-                          int& exp) {
-    // Non-fixed formats require at least one digit and no precision adjustment.
-    if (!fixed) return digits::more;
-    // Adjust fixed precision by exponent because it is relative to decimal
-    // point.
-    precision += exp + exp10;
-    // Check if precision is satisfied just by leading zeros, e.g.
-    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
-    if (precision > 0) return digits::more;
-    if (precision < 0) return digits::done;
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir == unknown) return digits::error;
-    buf[size++] = dir == up ? '1' : '0';
-    return digits::done;
-  }
+    void remove_leading_zeros()
+    {
+      int num_bigits = static_cast<int>(bigits_.size()) - 1;
+      while (num_bigits > 0 && bigits_[num_bigits] == 0)
+        --num_bigits;
+      bigits_.resize(num_bigits + 1);
+    }
 
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int, bool integral) {
-    FMT_ASSERT(remainder < divisor, "");
-    buf[size++] = digit;
-    if (size < precision) return digits::more;
-    if (!integral) {
-      // Check if error * 2 < divisor with overflow prevention.
-      // The check is not needed for the integral part because error = 1
-      // and divisor > (1 << 32) there.
-      if (error >= divisor || error >= divisor - error) return digits::error;
-    } else {
-      FMT_ASSERT(error == 1 && divisor > 2, "");
-    }
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir != up) return dir == down ? digits::done : digits::error;
-    ++buf[size - 1];
-    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
-      buf[i] = '0';
-      ++buf[i - 1];
-    }
-    if (buf[0] > '9') {
-      buf[0] = '1';
-      buf[size++] = '0';
-    }
-    return digits::done;
-  }
-};
+    // Computes *this -= other assuming aligned bigints and *this >= other.
+    void subtract_aligned(const bigint &other)
+    {
+      FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
+      FMT_ASSERT(compare(*this, other) >= 0, "");
+      bigit borrow = 0;
+      int   i      = other.exp_ - exp_;
+      for (int j = 0, n = static_cast<int>(other.bigits_.size()); j != n; ++i, ++j) {
+        subtract_bigits(i, other.bigits_[j], borrow);
+      }
+      while (borrow > 0)
+        subtract_bigits(i, 0, borrow);
+      remove_leading_zeros();
+    }
+
+    void multiply(uint32_t value)
+    {
+      const double_bigit wide_value = value;
+      bigit              carry      = 0;
+      for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+        double_bigit result = bigits_[i] * wide_value + carry;
+        bigits_[i]          = static_cast<bigit>(result);
+        carry               = static_cast<bigit>(result >> bigit_bits);
+      }
+      if (carry != 0)
+        bigits_.push_back(carry);
+    }
+
+    void multiply(uint64_t value)
+    {
+      const bigit        mask  = ~bigit(0);
+      const double_bigit lower = value & mask;
+      const double_bigit upper = value >> bigit_bits;
+      double_bigit       carry = 0;
+      for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+        double_bigit result = bigits_[i] * lower + (carry & mask);
+        carry               = bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
+        bigits_[i]          = static_cast<bigit>(result);
+      }
+      while (carry != 0) {
+        bigits_.push_back(carry & mask);
+        carry >>= bigit_bits;
+      }
+    }
+
+  public:
+    bigint() : exp_(0) {}
+    explicit bigint(uint64_t n) { assign(n); }
+    ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
+
+    bigint(const bigint &) = delete;
+    void operator=(const bigint &) = delete;
 
-// The shortest representation digit handler.
-template <int GRISU_VERSION> struct grisu_shortest_handler {
-  char* buf;
-  int size;
-  // Distance between scaled value and upper bound (wp_W in Grisu3).
-  uint64_t diff;
+    void assign(const bigint &other)
+    {
+      bigits_.resize(other.bigits_.size());
+      auto data = other.bigits_.data();
+      std::copy(data, data + other.bigits_.size(), bigits_.data());
+      exp_ = other.exp_;
+    }
+
+    void assign(uint64_t n)
+    {
+      int num_bigits = 0;
+      do {
+        bigits_[num_bigits++] = n & ~bigit(0);
+        n >>= bigit_bits;
+      } while (n != 0);
+      bigits_.resize(num_bigits);
+      exp_ = 0;
+    }
+
+    int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
+
+    bigint &operator<<=(int shift)
+    {
+      assert(shift >= 0);
+      exp_ += shift / bigit_bits;
+      shift %= bigit_bits;
+      if (shift == 0)
+        return *this;
+      bigit carry = 0;
+      for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+        bigit c    = bigits_[i] >> (bigit_bits - shift);
+        bigits_[i] = (bigits_[i] << shift) + carry;
+        carry      = c;
+      }
+      if (carry != 0)
+        bigits_.push_back(carry);
+      return *this;
+    }
+
+    template <typename Int> bigint &operator*=(Int value)
+    {
+      FMT_ASSERT(value > 0, "");
+      multiply(uint32_or_64_or_128_t<Int>(value));
+      return *this;
+    }
+
+    friend int compare(const bigint &lhs, const bigint &rhs)
+    {
+      int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
+      if (num_lhs_bigits != num_rhs_bigits)
+        return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
+      int i   = static_cast<int>(lhs.bigits_.size()) - 1;
+      int j   = static_cast<int>(rhs.bigits_.size()) - 1;
+      int end = i - j;
+      if (end < 0)
+        end = 0;
+      for (; i >= end; --i, --j) {
+        bigit lhs_bigit = lhs.bigits_[i], rhs_bigit = rhs.bigits_[j];
+        if (lhs_bigit != rhs_bigit)
+          return lhs_bigit > rhs_bigit ? 1 : -1;
+      }
+      if (i != j)
+        return i > j ? 1 : -1;
+      return 0;
+    }
+
+    // Returns compare(lhs1 + lhs2, rhs).
+    friend int add_compare(const bigint &lhs1, const bigint &lhs2, const bigint &rhs)
+    {
+      int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
+      int num_rhs_bigits = rhs.num_bigits();
+      if (max_lhs_bigits + 1 < num_rhs_bigits)
+        return -1;
+      if (max_lhs_bigits > num_rhs_bigits)
+        return 1;
+      auto get_bigit = [](const bigint &n, int i) -> bigit {
+        return i >= n.exp_ && i < n.num_bigits() ? n.bigits_[i - n.exp_] : 0;
+      };
+      double_bigit borrow  = 0;
+      int          min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
+      for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
+        double_bigit sum       = static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
+        bigit        rhs_bigit = get_bigit(rhs, i);
+        if (sum > rhs_bigit + borrow)
+          return 1;
+        borrow = rhs_bigit + borrow - sum;
+        if (borrow > 1)
+          return -1;
+        borrow <<= bigit_bits;
+      }
+      return borrow != 0 ? -1 : 0;
+    }
+
+    // Assigns pow(10, exp) to this bigint.
+    void assign_pow10(int exp)
+    {
+      assert(exp >= 0);
+      if (exp == 0)
+        return assign(1);
+      // Find the top bit.
+      int bitmask = 1;
+      while (exp >= bitmask)
+        bitmask <<= 1;
+      bitmask >>= 1;
+      // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
+      // repeated squaring and multiplication.
+      assign(5);
+      bitmask >>= 1;
+      while (bitmask != 0) {
+        square();
+        if ((exp & bitmask) != 0)
+          *this *= 5;
+        bitmask >>= 1;
+      }
+      *this <<= exp; // Multiply by pow(2, exp) by shifting.
+    }
+
+    void square()
+    {
+      basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
+      int                                         num_bigits = static_cast<int>(bigits_.size());
+      int                                         num_result_bigits = 2 * num_bigits;
+      bigits_.resize(num_result_bigits);
+      using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
+      auto sum            = accumulator_t();
+      for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
+        // Compute bigit at position bigit_index of the result by adding
+        // cross-product terms n[i] * n[j] such that i + j == bigit_index.
+        for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
+          // Most terms are multiplied twice which can be optimized in the future.
+          sum += static_cast<double_bigit>(n[i]) * n[j];
+        }
+        bigits_[bigit_index] = static_cast<bigit>(sum);
+        sum >>= bits<bigit>::value; // Compute the carry.
+      }
+      // Do the same for the top half.
+      for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) {
+        for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
+          sum += static_cast<double_bigit>(n[i++]) * n[j--];
+        bigits_[bigit_index] = static_cast<bigit>(sum);
+        sum >>= bits<bigit>::value;
+      }
+      --num_result_bigits;
+      remove_leading_zeros();
+      exp_ *= 2;
+    }
 
-  digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
-    return digits::more;
+    // Divides this bignum by divisor, assigning the remainder to this and
+    // returning the quotient.
+    int divmod_assign(const bigint &divisor)
+    {
+      FMT_ASSERT(this != &divisor, "");
+      if (compare(*this, divisor) < 0)
+        return 0;
+      int num_bigits = static_cast<int>(bigits_.size());
+      FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1] != 0, "");
+      int exp_difference = exp_ - divisor.exp_;
+      if (exp_difference > 0) {
+        // Align bigints by adding trailing zeros to simplify subtraction.
+        bigits_.resize(num_bigits + exp_difference);
+        for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
+          bigits_[j] = bigits_[i];
+        std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+        exp_ -= exp_difference;
+      }
+      int quotient = 0;
+      do {
+        subtract_aligned(divisor);
+        ++quotient;
+      } while (compare(*this, divisor) >= 0);
+      return quotient;
+    }
+  };
+
+  enum round_direction { unknown, up, down };
+
+  // Given the divisor (normally a power of 10), the remainder = v % divisor for
+  // some number v and the error, returns whether v should be rounded up, down, or
+  // whether the rounding direction can't be determined due to error.
+  // error should be less than divisor / 2.
+  inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder, uint64_t error)
+  {
+    FMT_ASSERT(remainder < divisor, "");     // divisor - remainder won't overflow.
+    FMT_ASSERT(error < divisor, "");         // divisor - error won't overflow.
+    FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow.
+    // Round down if (remainder + error) * 2 <= divisor.
+    if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
+      return down;
+    // Round up if (remainder - error) * 2 >= divisor.
+    if (remainder >= error && remainder - error >= divisor - (remainder - error)) {
+      return up;
+    }
+    return unknown;
   }
 
-  // Decrement the generated number approaching value from above.
-  void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
-             uint64_t error) {
-    while (
-        remainder < d && error - remainder >= divisor &&
-        (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
-      --buf[size - 1];
-      remainder += divisor;
+  namespace digits {
+    enum result {
+      more, // Generate more digits.
+      done, // Done generating digits.
+      error // Digit generation cancelled due to an error.
+    };
+  }
+
+  // Generates output using the Grisu digit-gen algorithm.
+  // error: the size of the region (lower, upper) outside of which numbers
+  // definitely do not round to value (Delta in Grisu3).
+  template <typename Handler>
+  digits::result grisu_gen_digits(fp value, uint64_t error, int &exp, Handler &handler)
+  {
+    const fp one(1ull << -value.e, value.e);
+    // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
+    // zero because it contains a product of two 64-bit numbers with MSB set (due
+    // to normalization) - 1, shifted right by at most 60 bits.
+    uint32_t integral = static_cast<uint32_t>(value.f >> -one.e);
+    FMT_ASSERT(integral != 0, "");
+    FMT_ASSERT(integral == value.f >> -one.e, "");
+    // The fractional part of scaled value (p2 in Grisu) c = value % one.
+    uint64_t fractional = value.f & (one.f - 1);
+    exp                 = count_digits(integral); // kappa in Grisu.
+    // Divide by 10 to prevent overflow.
+    auto result =
+        handler.on_start(data::powers_of_10_64[exp - 1] << -one.e, value.f / 10, error * 10, exp);
+    if (result != digits::more)
+      return result;
+    // Generate digits for the integral part. This can produce up to 10 digits.
+    do {
+      uint32_t digit           = 0;
+      auto     divmod_integral = [&](uint32_t divisor) {
+        digit = integral / divisor;
+        integral %= divisor;
+      };
+      // This optimization by Milo Yip reduces the number of integer divisions by
+      // one per iteration.
+      switch (exp) {
+      case 10: divmod_integral(1000000000); break;
+      case 9: divmod_integral(100000000); break;
+      case 8: divmod_integral(10000000); break;
+      case 7: divmod_integral(1000000); break;
+      case 6: divmod_integral(100000); break;
+      case 5: divmod_integral(10000); break;
+      case 4: divmod_integral(1000); break;
+      case 3: divmod_integral(100); break;
+      case 2: divmod_integral(10); break;
+      case 1:
+        digit    = integral;
+        integral = 0;
+        break;
+      default: FMT_ASSERT(false, "invalid number of digits");
+      }
+      --exp;
+      uint64_t remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
+      result             = handler.on_digit(static_cast<char>('0' + digit),
+                                data::powers_of_10_64[exp] << -one.e, remainder, error, exp, true);
+      if (result != digits::more)
+        return result;
+    } while (exp > 0);
+    // Generate digits for the fractional part.
+    for (;;) {
+      fractional *= 10;
+      error *= 10;
+      char digit = static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
+      fractional &= one.f - 1;
+      --exp;
+      result = handler.on_digit(digit, one.f, fractional, error, exp, false);
+      if (result != digits::more)
+        return result;
     }
   }
 
-  // Implements Grisu's round_weed.
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int exp, bool integral) {
-    buf[size++] = digit;
-    if (remainder >= error) return digits::more;
-    if (GRISU_VERSION != 3) {
-      uint64_t d = integral ? diff : diff * data::powers_of_10_64[-exp];
-      round(d, divisor, remainder, error);
+  // The fixed precision digit handler.
+  struct fixed_handler
+  {
+    char *buf;
+    int   size;
+    int   precision;
+    int   exp10;
+    bool  fixed;
+
+    digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error, int &exp)
+    {
+      // Non-fixed formats require at least one digit and no precision adjustment.
+      if (!fixed)
+        return digits::more;
+      // Adjust fixed precision by exponent because it is relative to decimal
+      // point.
+      precision += exp + exp10;
+      // Check if precision is satisfied just by leading zeros, e.g.
+      // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
+      if (precision > 0)
+        return digits::more;
+      if (precision < 0)
+        return digits::done;
+      auto dir = get_round_direction(divisor, remainder, error);
+      if (dir == unknown)
+        return digits::error;
+      buf[size++] = dir == up ? '1' : '0';
       return digits::done;
     }
-    uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
-    uint64_t up = (diff - 1) * unit;  // wp_Wup
-    round(up, divisor, remainder, error);
-    uint64_t down = (diff + 1) * unit;  // wp_Wdown
-    if (remainder < down && error - remainder >= divisor &&
-        (remainder + divisor < down ||
-         down - remainder > remainder + divisor - down)) {
-      return digits::error;
-    }
-    return 2 * unit <= remainder && remainder <= error - 4 * unit
-               ? digits::done
-               : digits::error;
-  }
-};
 
-template <typename Double,
-          enable_if_t<(sizeof(Double) == sizeof(uint64_t)), int>>
-FMT_API bool grisu_format(Double value, buffer<char>& buf, int precision,
-                          unsigned options, int& exp) {
-  FMT_ASSERT(value >= 0, "value is negative");
-  bool fixed = (options & grisu_options::fixed) != 0;
-  if (value <= 0) {  // <= instead of == to silence a warning.
-    if (precision <= 0 || !fixed) {
-      exp = 0;
-      buf.push_back('0');
-    } else {
-      exp = -precision;
-      buf.resize(precision);
-      std::uninitialized_fill_n(buf.data(), precision, '0');
+    digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error, int,
+                            bool integral)
+    {
+      FMT_ASSERT(remainder < divisor, "");
+      buf[size++] = digit;
+      if (size < precision)
+        return digits::more;
+      if (!integral) {
+        // Check if error * 2 < divisor with overflow prevention.
+        // The check is not needed for the integral part because error = 1
+        // and divisor > (1 << 32) there.
+        if (error >= divisor || error >= divisor - error)
+          return digits::error;
+      }
+      else {
+        FMT_ASSERT(error == 1 && divisor > 2, "");
+      }
+      auto dir = get_round_direction(divisor, remainder, error);
+      if (dir != up)
+        return dir == down ? digits::done : digits::error;
+      ++buf[size - 1];
+      for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
+        buf[i] = '0';
+        ++buf[i - 1];
+      }
+      if (buf[0] > '9') {
+        buf[0]      = '1';
+        buf[size++] = '0';
+      }
+      return digits::done;
     }
-    return true;
-  }
+  };
 
-  fp fp_value(value);
-  const int min_exp = -60;  // alpha in Grisu.
-  int cached_exp10 = 0;     // K in Grisu.
-  if (precision != -1) {
-    if (precision > 17) return false;
-    fp_value.normalize();
-    auto cached_pow = get_cached_power(
-        min_exp - (fp_value.e + fp::significand_size), cached_exp10);
-    fp_value = fp_value * cached_pow;
-    fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
-    if (grisu_gen_digits(fp_value, 1, exp, handler) == digits::error)
-      return false;
-    buf.resize(to_unsigned(handler.size));
-  } else {
-    fp lower, upper;  // w^- and w^+ in the Grisu paper.
-    fp_value.compute_boundaries(lower, upper);
-    // Find a cached power of 10 such that multiplying upper by it will bring
-    // the exponent in the range [min_exp, -32].
-    auto cached_pow = get_cached_power(  // \tilde{c}_{-k} in Grisu.
-        min_exp - (upper.e + fp::significand_size), cached_exp10);
-    fp_value.normalize();
-    fp_value = fp_value * cached_pow;
-    lower = lower * cached_pow;  // \tilde{M}^- in Grisu.
-    upper = upper * cached_pow;  // \tilde{M}^+ in Grisu.
-    assert(min_exp <= upper.e && upper.e <= -32);
-    auto result = digits::result();
-    int size = 0;
-    if ((options & grisu_options::grisu3) != 0) {
-      --lower.f;  // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
-      ++upper.f;  // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
-      // Numbers outside of (lower, upper) definitely do not round to value.
-      grisu_shortest_handler<3> handler{buf.data(), 0, (upper - fp_value).f};
-      result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
-      size = handler.size;
-    } else {
-      ++lower.f;  // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
-      --upper.f;  // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
-      grisu_shortest_handler<2> handler{buf.data(), 0, (upper - fp_value).f};
-      result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
-      size = handler.size;
-    }
-    if (result == digits::error) return false;
-    buf.resize(to_unsigned(size));
-  }
-  exp -= cached_exp10;
-  return true;
-}
+  // The shortest representation digit handler.
+  template <int GRISU_VERSION> struct grisu_shortest_handler
+  {
+    char *buf;
+    int   size;
+    // Distance between scaled value and upper bound (wp_W in Grisu3).
+    uint64_t diff;
+
+    digits::result on_start(uint64_t, uint64_t, uint64_t, int &) { return digits::more; }
+
+    // Decrement the generated number approaching value from above.
+    void round(uint64_t d, uint64_t divisor, uint64_t &remainder, uint64_t error)
+    {
+      while (remainder < d && error - remainder >= divisor &&
+             (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
+        --buf[size - 1];
+        remainder += divisor;
+      }
+    }
+
+    // Implements Grisu's round_weed.
+    digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error,
+                            int exp, bool integral)
+    {
+      buf[size++] = digit;
+      if (remainder >= error)
+        return digits::more;
+      if (const_check(GRISU_VERSION != 3)) {
+        uint64_t d = integral ? diff : diff * data::powers_of_10_64[-exp];
+        round(d, divisor, remainder, error);
+        return digits::done;
+      }
+      uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
+      uint64_t up   = (diff - 1) * unit; // wp_Wup
+      round(up, divisor, remainder, error);
+      uint64_t down = (diff + 1) * unit; // wp_Wdown
+      if (remainder < down && error - remainder >= divisor &&
+          (remainder + divisor < down || down - remainder > remainder + divisor - down)) {
+        return digits::error;
+      }
+      return 2 * unit <= remainder && remainder <= error - 4 * unit ? digits::done : digits::error;
+    }
+  };
 
-template <typename Double>
-char* sprintf_format(Double value, internal::buffer<char>& buf,
-                     sprintf_specs specs) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() != 0, "empty buffer");
-
-  // Build format string.
-  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.alt || !specs.type) *format_ptr++ = '#';
-  if (specs.precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
+  // Formats value using a variation of the Fixed-Precision Positive
+  // Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
+  // https://fmt.dev/p372-steele.pdf.
+  template <typename Double> void fallback_format(Double d, buffer<char> &buf, int &exp10)
+  {
+    bigint numerator;   // 2 * R in (FPP)^2.
+    bigint denominator; // 2 * S in (FPP)^2.
+    // lower and upper are differences between value and corresponding boundaries.
+    bigint  lower;           // (M^- in (FPP)^2).
+    bigint  upper_store;     // upper's value if different from lower.
+    bigint *upper = nullptr; // (M^+ in (FPP)^2).
+    fp      value;
+    // Shift numerator and denominator by an extra bit or two (if lower boundary
+    // is closer) to make lower and upper integers. This eliminates multiplication
+    // by 2 during later computations.
+    // TODO: handle float
+    int      shift       = value.assign(d) ? 2 : 1;
+    uint64_t significand = value.f << shift;
+    if (value.e >= 0) {
+      numerator.assign(significand);
+      numerator <<= value.e;
+      lower.assign(1);
+      lower <<= value.e;
+      if (shift != 1) {
+        upper_store.assign(1);
+        upper_store <<= value.e + 1;
+        upper = &upper_store;
+      }
+      denominator.assign_pow10(exp10);
+      denominator <<= 1;
+    }
+    else if (exp10 < 0) {
+      numerator.assign_pow10(-exp10);
+      lower.assign(numerator);
+      if (shift != 1) {
+        upper_store.assign(numerator);
+        upper_store <<= 1;
+        upper = &upper_store;
+      }
+      numerator *= significand;
+      denominator.assign(1);
+      denominator <<= shift - value.e;
+    }
+    else {
+      numerator.assign(significand);
+      denominator.assign_pow10(exp10);
+      denominator <<= shift - value.e;
+      lower.assign(1);
+      if (shift != 1) {
+        upper_store.assign(1ull << 1);
+        upper = &upper_store;
+      }
+    }
+    if (!upper)
+      upper = &lower;
+    // Invariant: value == (numerator / denominator) * pow(10, exp10).
+    bool  even       = (value.f & 1) == 0;
+    int   num_digits = 0;
+    char *data       = buf.data();
+    for (;;) {
+      int  digit = numerator.divmod_assign(denominator);
+      bool low   = compare(numerator, lower) - even < 0; // numerator <[=] lower.
+      // numerator + upper >[=] pow10:
+      bool high          = add_compare(numerator, *upper, denominator) + even > 0;
+      data[num_digits++] = static_cast<char>('0' + digit);
+      if (low || high) {
+        if (!low) {
+          ++data[num_digits - 1];
+        }
+        else if (high) {
+          int result = add_compare(numerator, numerator, denominator);
+          // Round half to even.
+          if (result > 0 || (result == 0 && (digit % 2) != 0))
+            ++data[num_digits - 1];
+        }
+        buf.resize(num_digits);
+        exp10 -= num_digits - 1;
+        return;
+      }
+      numerator *= 10;
+      lower *= 10;
+      if (upper != &lower)
+        *upper *= 10;
+    }
   }
-  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
-
-  char type = specs.type;
-
-  if (type == '%')
-    type = 'f';
-  else if (type == 0 || type == 'n')
-    type = 'g';
-#if FMT_MSC_VER
-  if (type == 'F') {
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
+
+  template <typename Double, enable_if_t<(sizeof(Double) == sizeof(uint64_t)), int>>
+  bool grisu_format(Double value, buffer<char> &buf, int precision, unsigned options, int &exp)
+  {
+    FMT_ASSERT(value >= 0, "value is negative");
+    const bool fixed = (options & grisu_options::fixed) != 0;
+    if (value <= 0) { // <= instead of == to silence a warning.
+      if (precision <= 0 || !fixed) {
+        exp = 0;
+        buf.push_back('0');
+      }
+      else {
+        exp = -precision;
+        buf.resize(to_unsigned(precision));
+        std::uninitialized_fill_n(buf.data(), precision, '0');
+      }
+      return true;
+    }
+
+    const int min_exp      = -60; // alpha in Grisu.
+    int       cached_exp10 = 0;   // K in Grisu.
+    if (precision != -1) {
+      if (precision > 17)
+        return false;
+      fp         fp_value(value);
+      fp         normalized = normalize(fp_value);
+      const auto cached_pow =
+          get_cached_power(min_exp - (normalized.e + fp::significand_size), cached_exp10);
+      normalized = normalized * cached_pow;
+      fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
+      if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
+        return false;
+      int num_digits = handler.size;
+      if (!fixed) {
+        // Remove trailing zeros.
+        while (num_digits > 0 && buf[num_digits - 1] == '0') {
+          --num_digits;
+          ++exp;
+        }
+      }
+      buf.resize(to_unsigned(num_digits));
+    }
+    else {
+      fp fp_value;
+      fp lower, upper; // w^- and w^+ in the Grisu paper.
+      if ((options & grisu_options::binary32) != 0)
+        fp_value.assign_float_with_boundaries(value, lower, upper);
+      else
+        fp_value.assign_with_boundaries(value, lower, upper);
+
+      // Find a cached power of 10 such that multiplying upper by it will bring
+      // the exponent in the range [min_exp, -32].
+      const auto cached_pow = get_cached_power( // \tilde{c}_{-k} in Grisu.
+          min_exp - (upper.e + fp::significand_size), cached_exp10);
+      fp         normalized = normalize(fp_value);
+      normalized            = normalized * cached_pow;
+      lower                 = lower * cached_pow; // \tilde{M}^- in Grisu.
+      upper                 = upper * cached_pow; // \tilde{M}^+ in Grisu.
+      assert(min_exp <= upper.e && upper.e <= -32);
+      auto result = digits::result();
+      int  size   = 0;
+      if ((options & grisu_options::grisu2) != 0) {
+        ++lower.f; // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
+        --upper.f; // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
+        grisu_shortest_handler<2> handler{buf.data(), 0, (upper - normalized).f};
+        result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
+        size   = handler.size;
+        assert(result != digits::error);
+      }
+      else {
+        --lower.f; // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
+        ++upper.f; // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
+        // Numbers outside of (lower, upper) definitely do not round to value.
+        grisu_shortest_handler<3> handler{buf.data(), 0, (upper - normalized).f};
+        result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
+        size   = handler.size;
+        if (result == digits::error) {
+          exp = exp + size - cached_exp10 - 1;
+          fallback_format(value, buf, exp);
+          return true;
+        }
+      }
+      buf.resize(to_unsigned(size));
+    }
+    exp -= cached_exp10;
+    return true;
   }
-#endif
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  char* start = nullptr;
-  char* decimal_point_pos = nullptr;
-  for (;;) {
-    std::size_t buffer_size = buf.capacity();
-    start = &buf[0];
-    int result =
-        format_float(start, buffer_size, format, specs.precision, value);
-    if (result >= 0) {
-      unsigned n = internal::to_unsigned(result);
-      if (n < buf.capacity()) {
-        // Find the decimal point.
-        auto p = buf.data(), end = p + n;
-        if (*p == '+' || *p == '-') ++p;
-        if (specs.type != 'a' && specs.type != 'A') {
-          while (p < end && *p >= '0' && *p <= '9') ++p;
-          if (p < end && *p != 'e' && *p != 'E') {
-            decimal_point_pos = p;
-            if (!specs.type) {
-              // Keep only one trailing zero after the decimal point.
+
+  template <typename Double>
+  char *sprintf_format(Double value, internal::buffer<char> &buf, sprintf_specs specs)
+  {
+    // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+    FMT_ASSERT(buf.capacity() != 0, "empty buffer");
+
+    // Build format string.
+    enum { max_format_size = 10 }; // longest format: %#-*.*Lg
+    char  format[max_format_size];
+    char *format_ptr = format;
+    *format_ptr++    = '%';
+    if (specs.alt || !specs.type)
+      *format_ptr++ = '#';
+    if (specs.precision >= 0) {
+      *format_ptr++ = '.';
+      *format_ptr++ = '*';
+    }
+    if (std::is_same<Double, long double>::value)
+      *format_ptr++ = 'L';
+
+    char type = specs.type;
+
+    if (type == '%')
+      type = 'f';
+    else if (type == 0 || type == 'n')
+      type = 'g';
+    if (FMT_MSC_VER && type == 'F')
+      type = 'f'; // // MSVC's printf doesn't support 'F'.
+    *format_ptr++ = type;
+    *format_ptr   = '\0';
+
+    // Format using snprintf.
+    char *start             = nullptr;
+    char *decimal_point_pos = nullptr;
+    for (;;) {
+      std::size_t buffer_size = buf.capacity();
+      start                   = &buf[0];
+      int result              = format_float(start, buffer_size, format, specs.precision, value);
+      if (result >= 0) {
+        unsigned n = internal::to_unsigned(result);
+        if (n < buf.capacity()) {
+          // Find the decimal point.
+          auto p = buf.data(), end = p + n;
+          if (*p == '+' || *p == '-')
+            ++p;
+          if (specs.type != 'a' && specs.type != 'A') {
+            while (p < end && *p >= '0' && *p <= '9')
               ++p;
-              if (*p == '0') ++p;
-              while (p != end && *p >= '1' && *p <= '9') ++p;
-              char* where = p;
-              while (p != end && *p == '0') ++p;
-              if (p == end || *p < '0' || *p > '9') {
-                if (p != end) std::memmove(where, p, to_unsigned(end - p));
-                n -= static_cast<unsigned>(p - where);
+            if (p < end && *p != 'e' && *p != 'E') {
+              decimal_point_pos = p;
+              if (!specs.type) {
+                // Keep only one trailing zero after the decimal point.
+                ++p;
+                if (*p == '0')
+                  ++p;
+                while (p != end && *p >= '1' && *p <= '9')
+                  ++p;
+                char *where = p;
+                while (p != end && *p == '0')
+                  ++p;
+                if (p == end || *p < '0' || *p > '9') {
+                  if (p != end)
+                    std::memmove(where, p, to_unsigned(end - p));
+                  n -= static_cast<unsigned>(p - where);
+                }
               }
             }
           }
+          buf.resize(n);
+          break; // The buffer is large enough - continue with formatting.
         }
-        buf.resize(n);
-        break;  // The buffer is large enough - continue with formatting.
+        buf.reserve(n + 1);
+      }
+      else {
+        // If result is negative we ask to increase the capacity by at least 1,
+        // but as std::vector, the buffer grows exponentially.
+        buf.reserve(buf.capacity() + 1);
       }
-      buf.reserve(n + 1);
-    } else {
-      // If result is negative we ask to increase the capacity by at least 1,
-      // but as std::vector, the buffer grows exponentially.
-      buf.reserve(buf.capacity() + 1);
     }
+    return decimal_point_pos;
   }
-  return decimal_point_pos;
-}
-}  // namespace internal
+} // namespace internal
+
+template <> struct formatter<internal::bigint>
+{
+  format_parse_context::iterator parse(format_parse_context &ctx) { return ctx.begin(); }
+
+  format_context::iterator format(const internal::bigint &n, format_context &ctx)
+  {
+    auto out   = ctx.out();
+    bool first = true;
+    for (auto i = n.bigits_.size(); i > 0; --i) {
+      auto value = n.bigits_[i - 1];
+      if (first) {
+        out   = format_to(out, "{:x}", value);
+        first = false;
+        continue;
+      }
+      out = format_to(out, "{:08x}", value);
+    }
+    if (n.exp_ > 0)
+      out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
+    return out;
+  }
+};
 
 #if FMT_USE_WINDOWS_H
 
-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s)
+{
   static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
   if (s.size() > INT_MAX)
     FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
@@ -845,25 +1269,28 @@ FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
     return;
   }
 
-  int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(),
-                                   s_size, nullptr, 0);
-  if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
+  int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, nullptr, 0);
+  if (length == 0)
+    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_.resize(length + 1);
-  length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size,
-                               &buffer_[0], length);
-  if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
+  length =
+      MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
+  if (length == 0)
+    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_[length] = 0;
 }
 
-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
+FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s)
+{
   if (int error_code = convert(s)) {
-    FMT_THROW(windows_error(error_code,
-                            "cannot convert string from UTF-16 to UTF-8"));
+    FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8"));
   }
 }
 
-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
-  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
+FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s)
+{
+  if (s.size() > INT_MAX)
+    return ERROR_INVALID_PARAMETER;
   int s_size = static_cast<int>(s.size());
   if (s_size == 0) {
     // WideCharToMultiByte does not support zero length, handle separately.
@@ -872,38 +1299,38 @@ FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
     return 0;
   }
 
-  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
-                                   nullptr, nullptr);
-  if (length == 0) return GetLastError();
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0, nullptr, nullptr);
+  if (length == 0)
+    return GetLastError();
   buffer_.resize(length + 1);
-  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
-                               length, nullptr, nullptr);
-  if (length == 0) return GetLastError();
+  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, nullptr, nullptr);
+  if (length == 0)
+    return GetLastError();
   buffer_[length] = 0;
   return 0;
 }
 
-FMT_FUNC void windows_error::init(int err_code, string_view format_str,
-                                  format_args args) {
+FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args)
+{
   error_code_ = err_code;
   memory_buffer buffer;
   internal::format_windows_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error& base = *this;
-  base = std::runtime_error(to_string(buffer));
+  std::runtime_error &base = *this;
+  base                     = std::runtime_error(to_string(buffer));
 }
 
-FMT_FUNC void internal::format_windows_error(internal::buffer<char>& out,
-                                             int error_code,
-                                             string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
+FMT_FUNC void internal::format_windows_error(internal::buffer<char> &out, int error_code,
+                                             string_view message) FMT_NOEXCEPT
+{
+  FMT_TRY
+  {
     wmemory_buffer buf;
     buf.resize(inline_buffer_size);
     for (;;) {
-      wchar_t* system_message = &buf[0];
-      int result = FormatMessageW(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
-          error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
-          static_cast<uint32_t>(buf.size()), nullptr);
+      wchar_t *system_message = &buf[0];
+      int      result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                                  nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                                  system_message, static_cast<uint32_t>(buf.size()), nullptr);
       if (result != 0) {
         utf16_to_utf8 utf8_message;
         if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
@@ -916,7 +1343,7 @@ FMT_FUNC void internal::format_windows_error(internal::buffer<char>& out,
         break;
       }
       if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-        break;  // Can't get error message, report error code instead.
+        break; // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
   }
@@ -924,17 +1351,18 @@ FMT_FUNC void internal::format_windows_error(internal::buffer<char>& out,
   format_error_code(out, error_code, message);
 }
 
-#endif  // FMT_USE_WINDOWS_H
+#endif // FMT_USE_WINDOWS_H
 
-FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
-                                  string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
+FMT_FUNC void format_system_error(internal::buffer<char> &out, int error_code,
+                                  string_view message) FMT_NOEXCEPT
+{
+  FMT_TRY
+  {
     memory_buffer buf;
     buf.resize(inline_buffer_size);
     for (;;) {
-      char* system_message = &buf[0];
-      int result =
-          internal::safe_strerror(error_code, system_message, buf.size());
+      char *system_message = &buf[0];
+      int   result         = internal::safe_strerror(error_code, system_message, buf.size());
       if (result == 0) {
         internal::writer w(out);
         w.write(message);
@@ -943,7 +1371,7 @@ FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
         return;
       }
       if (result != ERANGE)
-        break;  // Can't get error message, report error code instead.
+        break; // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
   }
@@ -951,30 +1379,32 @@ FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
   format_error_code(out, error_code, message);
 }
 
-FMT_FUNC void internal::error_handler::on_error(const char* message) {
+FMT_FUNC void internal::error_handler::on_error(const char *message)
+{
   FMT_THROW(format_error(message));
 }
 
-FMT_FUNC void report_system_error(int error_code,
-                                  fmt::string_view message) FMT_NOEXCEPT {
+FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+{
   report_error(format_system_error, error_code, message);
 }
 
 #if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(int error_code,
-                                   fmt::string_view message) FMT_NOEXCEPT {
+FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+{
   report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
+{
   memory_buffer buffer;
-  internal::vformat_to(buffer, format_str,
-                       basic_format_args<buffer_context<char>>(args));
+  internal::vformat_to(buffer, format_str, basic_format_args<buffer_context<char>>(args));
   internal::fwrite_fully(buffer.data(), 1, buffer.size(), f);
 }
 
-FMT_FUNC void vprint(std::FILE* f, wstring_view format_str, wformat_args args) {
+FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args)
+{
   wmemory_buffer buffer;
   internal::vformat_to(buffer, format_str, args);
   buffer.push_back(L'\0');
@@ -983,18 +1413,17 @@ FMT_FUNC void vprint(std::FILE* f, wstring_view format_str, wformat_args args) {
   }
 }
 
-FMT_FUNC void vprint(string_view format_str, format_args args) {
-  vprint(stdout, format_str, args);
-}
+FMT_FUNC void vprint(string_view format_str, format_args args) { vprint(stdout, format_str, args); }
 
-FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
+FMT_FUNC void vprint(wstring_view format_str, wformat_args args)
+{
   vprint(stdout, format_str, args);
 }
 
 FMT_END_NAMESPACE
 
 #ifdef _MSC_VER
-#  pragma warning(pop)
+#pragma warning(pop)
 #endif
 
-#endif  // FMT_FORMAT_INL_H_
+#endif // FMT_FORMAT_INL_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/format.h b/packages/seacas/libraries/ioss/src/fmt/format.h
index acc39c40614a..483252d30a8d 100644
--- a/packages/seacas/libraries/ioss/src/fmt/format.h
+++ b/packages/seacas/libraries/ioss/src/fmt/format.h
@@ -46,454 +46,475 @@
 #include "core.h"
 
 #ifdef __clang__
-#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
 #else
-#  define FMT_CLANG_VERSION 0
+#define FMT_CLANG_VERSION 0
 #endif
 
 #ifdef __INTEL_COMPILER
-#  define FMT_ICC_VERSION __INTEL_COMPILER
+#define FMT_ICC_VERSION __INTEL_COMPILER
 #elif defined(__ICL)
-#  define FMT_ICC_VERSION __ICL
+#define FMT_ICC_VERSION __ICL
 #else
-#  define FMT_ICC_VERSION 0
+#define FMT_ICC_VERSION 0
 #endif
 
 #ifdef __NVCC__
-#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
+#define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
 #else
-#  define FMT_CUDA_VERSION 0
+#define FMT_CUDA_VERSION 0
 #endif
 
 #ifdef __has_builtin
-#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#define FMT_HAS_BUILTIN(x) __has_builtin(x)
 #else
-#  define FMT_HAS_BUILTIN(x) 0
+#define FMT_HAS_BUILTIN(x) 0
 #endif
 
 #ifndef FMT_THROW
-#  if FMT_EXCEPTIONS
-#    if FMT_MSC_VER
+#if FMT_EXCEPTIONS
+#if FMT_MSC_VER
 FMT_BEGIN_NAMESPACE
 namespace internal {
-template <typename Exception> inline void do_throw(const Exception& x) {
-  // Silence unreachable code warnings in MSVC because these are nearly
-  // impossible to fix in a generic code.
-  volatile bool b = true;
-  if (b) throw x;
-}
-}  // namespace internal
+  template <typename Exception> inline void do_throw(const Exception &x)
+  {
+    // Silence unreachable code warnings in MSVC because these are nearly
+    // impossible to fix in a generic code.
+    volatile bool b = true;
+    if (b)
+      throw x;
+  }
+} // namespace internal
 FMT_END_NAMESPACE
-#      define FMT_THROW(x) fmt::internal::do_throw(x)
-#    else
-#      define FMT_THROW(x) throw x
-#    endif
-#  else
-#    define FMT_THROW(x)              \
-      do {                            \
-        static_cast<void>(sizeof(x)); \
-        assert(false);                \
-      } while (false)
-#  endif
+#define FMT_THROW(x) fmt::internal::do_throw(x)
+#else
+#define FMT_THROW(x) throw x
+#endif
+#else
+#define FMT_THROW(x)                                                                               \
+  do {                                                                                             \
+    static_cast<void>(sizeof(x));                                                                  \
+    assert(false);                                                                                 \
+  } while (false)
+#endif
 #endif
 
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
-#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 ||      \
-       FMT_MSC_VER >= 1900) &&                                              \
-      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
-       FMT_CUDA_VERSION >= 700)
-#    define FMT_USE_USER_DEFINED_LITERALS 1
-#  else
-#    define FMT_USE_USER_DEFINED_LITERALS 0
-#  endif
+#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) &&       \
+    (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || FMT_CUDA_VERSION >= 700)
+#define FMT_USE_USER_DEFINED_LITERALS 1
+#else
+#define FMT_USE_USER_DEFINED_LITERALS 0
+#endif
 #endif
 
 #ifndef FMT_USE_UDL_TEMPLATE
 // EDG front end based compilers (icc, nvcc) do not support UDL templates yet
 // and GCC 9 warns about them.
-#  if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
-      FMT_CUDA_VERSION == 0 &&                                 \
-      ((FMT_GCC_VERSION >= 600 && FMT_GCC_VERSION <= 900 &&    \
-        __cplusplus >= 201402L) ||                             \
-       FMT_CLANG_VERSION >= 304)
-#    define FMT_USE_UDL_TEMPLATE 1
-#  else
-#    define FMT_USE_UDL_TEMPLATE 0
-#  endif
-#endif
-
-#ifdef FMT_USE_INT128
-// Do nothing.
-#elif defined(__SIZEOF_INT128__)
-#  define FMT_USE_INT128 1
+#if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && FMT_CUDA_VERSION == 0 &&              \
+    ((FMT_GCC_VERSION >= 600 && FMT_GCC_VERSION <= 900 && __cplusplus >= 201402L) ||               \
+     FMT_CLANG_VERSION >= 304)
+#define FMT_USE_UDL_TEMPLATE 1
 #else
-#  define FMT_USE_INT128 0
+#define FMT_USE_UDL_TEMPLATE 0
+#endif
 #endif
 
 // __builtin_clz is broken in clang with Microsoft CodeGen:
 // https://github.com/fmtlib/fmt/issues/519
 #if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
 #endif
 #if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
 #endif
 
 // Some compilers masquerade as both MSVC and GCC-likes or otherwise support
 // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
 // MSVC intrinsics if the clz and clzll builtins are not available.
 #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
-#  include <intrin.h>  // _BitScanReverse, _BitScanReverse64
+#include <intrin.h> // _BitScanReverse, _BitScanReverse64
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#  ifndef __clang__
-#    pragma intrinsic(_BitScanReverse)
-#  endif
-inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
-
-  assert(x != 0);
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 31 - r;
-}
-#  define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
-
-#  if defined(_WIN64) && !defined(__clang__)
-#    pragma intrinsic(_BitScanReverse64)
-#  endif
-
-inline uint32_t clzll(uint64_t x) {
-  unsigned long r = 0;
-#  ifdef _WIN64
-  _BitScanReverse64(&r, x);
-#  else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);
-
-  // Scan the low 32 bits.
-  _BitScanReverse(&r, static_cast<uint32_t>(x));
-#  endif
-
-  assert(x != 0);
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 63 - r;
-}
-#  define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-}  // namespace internal
+#ifndef __clang__
+#pragma intrinsic(_BitScanReverse)
+#endif
+  inline uint32_t clz(uint32_t x)
+  {
+    unsigned long r = 0;
+    _BitScanReverse(&r, x);
+
+    assert(x != 0);
+    // Static analysis complains about using uninitialized data
+    // "r", but the only way that can happen is if "x" is 0,
+    // which the callers guarantee to not happen.
+#pragma warning(suppress : 6102)
+    return 31 - r;
+  }
+#define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
+
+#if defined(_WIN64) && !defined(__clang__)
+#pragma intrinsic(_BitScanReverse64)
+#endif
+
+  inline uint32_t clzll(uint64_t x)
+  {
+    unsigned long r = 0;
+#ifdef _WIN64
+    _BitScanReverse64(&r, x);
+#else
+    // Scan the high 32 bits.
+    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+      return 63 - (r + 32);
+
+    // Scan the low 32 bits.
+    _BitScanReverse(&r, static_cast<uint32_t>(x));
+#endif
+
+    assert(x != 0);
+    // Static analysis complains about using uninitialized data
+    // "r", but the only way that can happen is if "x" is 0,
+    // which the callers guarantee to not happen.
+#pragma warning(suppress : 6102)
+    return 63 - r;
+  }
+#define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
+} // namespace internal
 FMT_END_NAMESPACE
 #endif
 
+#ifndef FMT_NUMERIC_ALIGN
+#define FMT_NUMERIC_ALIGN 1
+#endif
+
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-// A fallback implementation of uintptr_t for systems that lack it.
-struct fallback_uintptr {
-  unsigned char value[sizeof(void*)];
-};
+  // A helper function to suppress bogus "conditional expression is constant"
+  // warnings.
+  template <typename T> inline T const_check(T value) { return value; }
+
+  // A fallback implementation of uintptr_t for systems that lack it.
+  struct fallback_uintptr
+  {
+    unsigned char value[sizeof(void *)];
+  };
 #ifdef UINTPTR_MAX
-using uintptr_t = ::uintptr_t;
+  using uintptr_t = ::uintptr_t;
 #else
-using uintptr_t = fallback_uintptr;
+  using uintptr_t                         = fallback_uintptr;
 #endif
 
-// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
-// undefined behavior (e.g. due to type aliasing).
-// Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template <typename Dest, typename Source>
-inline Dest bit_cast(const Source& source) {
-  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-  Dest dest;
-  std::memcpy(&dest, &source, sizeof(dest));
-  return dest;
-}
-
-// An approximation of iterator_t for pre-C++20 systems.
-template <typename T>
-using iterator_t = decltype(std::begin(std::declval<T&>()));
-
-// Detect the iterator category of *any* given type in a SFINAE-friendly way.
-// Unfortunately, older implementations of std::iterator_traits are not safe
-// for use in a SFINAE-context.
-template <typename It, typename Enable = void>
-struct iterator_category : std::false_type {};
+  // An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
+  // undefined behavior (e.g. due to type aliasing).
+  // Example: uint64_t d = bit_cast<uint64_t>(2.718);
+  template <typename Dest, typename Source> inline Dest bit_cast(const Source &source)
+  {
+    static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
+    Dest dest;
+    std::memcpy(&dest, &source, sizeof(dest));
+    return dest;
+  }
+
+  // Returns the largest possible value for type T. Same as
+  // std::numeric_limits<T>::max() but shorter and not affected by the max macro.
+  template <typename T> constexpr T max_value() { return (std::numeric_limits<T>::max)(); }
+
+  // An approximation of iterator_t for pre-C++20 systems.
+  template <typename T> using iterator_t = decltype(std::begin(std::declval<T &>()));
+
+  // Detect the iterator category of *any* given type in a SFINAE-friendly way.
+  // Unfortunately, older implementations of std::iterator_traits are not safe
+  // for use in a SFINAE-context.
+  template <typename It, typename Enable = void> struct iterator_category : std::false_type
+  {
+  };
 
-template <typename T> struct iterator_category<T*> {
-  using type = std::random_access_iterator_tag;
-};
+  template <typename T> struct iterator_category<T *>
+  {
+    using type = std::random_access_iterator_tag;
+  };
 
-template <typename It>
-struct iterator_category<It, void_t<typename It::iterator_category>> {
-  using type = typename It::iterator_category;
-};
+  template <typename It> struct iterator_category<It, void_t<typename It::iterator_category>>
+  {
+    using type = typename It::iterator_category;
+  };
 
-// Detect if *any* given type models the OutputIterator concept.
-template <typename It> class is_output_iterator {
-  // Check for mutability because all iterator categories derived from
-  // std::input_iterator_tag *may* also meet the requirements of an
-  // OutputIterator, thereby falling into the category of 'mutable iterators'
-  // [iterator.requirements.general] clause 4. The compiler reveals this
-  // property only at the point of *actually dereferencing* the iterator!
-  template <typename U>
-  static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
-  template <typename U> static char& test(std::output_iterator_tag);
-  template <typename U> static const char& test(...);
-
-  using type = decltype(test<It>(typename iterator_category<It>::type{}));
-
- public:
-  static const bool value = !std::is_const<remove_reference_t<type>>::value;
-};
+  // Detect if *any* given type models the OutputIterator concept.
+  template <typename It> class is_output_iterator
+  {
+    // Check for mutability because all iterator categories derived from
+    // std::input_iterator_tag *may* also meet the requirements of an
+    // OutputIterator, thereby falling into the category of 'mutable iterators'
+    // [iterator.requirements.general] clause 4. The compiler reveals this
+    // property only at the point of *actually dereferencing* the iterator!
+    template <typename U> static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
+    template <typename U> static char &                         test(std::output_iterator_tag);
+    template <typename U> static const char &                   test(...);
+
+    using type = decltype(test<It>(typename iterator_category<It>::type{}));
+
+  public:
+    static const bool value = !std::is_const<remove_reference_t<type>>::value;
+  };
 
-// A workaround for std::string not having mutable data() until C++17.
-template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
-  return &s[0];
-}
-template <typename Container>
-inline typename Container::value_type* get_data(Container& c) {
-  return c.data();
-}
+  // A workaround for std::string not having mutable data() until C++17.
+  template <typename Char> inline Char *get_data(std::basic_string<Char> &s) { return &s[0]; }
+  template <typename Container> inline typename Container::value_type *get_data(Container &c)
+  {
+    return c.data();
+  }
 
 #ifdef _SECURE_SCL
-// Make a checked iterator to avoid MSVC warnings.
-template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
-template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
-  return {p, size};
-}
+  // Make a checked iterator to avoid MSVC warnings.
+  template <typename T> using checked_ptr = stdext::checked_array_iterator<T *>;
+  template <typename T> checked_ptr<T> make_checked(T *p, std::size_t size) { return {p, size}; }
 #else
-template <typename T> using checked_ptr = T*;
-template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
+  template <typename T> using checked_ptr = T *;
+  template <typename T> inline T *make_checked(T *p, std::size_t) { return p; }
 #endif
 
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline checked_ptr<typename Container::value_type> reserve(
-    std::back_insert_iterator<Container>& it, std::size_t n) {
-  Container& c = get_container(it);
-  std::size_t size = c.size();
-  c.resize(size + n);
-  return make_checked(get_data(c) + size, n);
-}
-
-template <typename Iterator>
-inline Iterator& reserve(Iterator& it, std::size_t) {
-  return it;
-}
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-template <typename T> class counting_iterator {
- private:
-  std::size_t count_;
-  mutable T blackhole_;
+  template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+  inline checked_ptr<typename Container::value_type>
+  reserve(std::back_insert_iterator<Container> &it, std::size_t n)
+  {
+    Container & c    = get_container(it);
+    std::size_t size = c.size();
+    c.resize(size + n);
+    return make_checked(get_data(c) + size, n);
+  }
+
+  template <typename Iterator> inline Iterator &reserve(Iterator &it, std::size_t) { return it; }
+
+  // An output iterator that counts the number of objects written to it and
+  // discards them.
+  class counting_iterator
+  {
+  private:
+    std::size_t count_;
+
+  public:
+    using iterator_category = std::output_iterator_tag;
+    using difference_type   = std::ptrdiff_t;
+    using pointer           = void;
+    using reference         = void;
+    using _Unchecked_type   = counting_iterator; // Mark iterator as checked.
+
+    struct value_type
+    {
+      template <typename T> void operator=(const T &) {}
+    };
 
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using difference_type = std::ptrdiff_t;
-  using pointer = T*;
-  using reference = T&;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+    counting_iterator() : count_(0) {}
 
-  counting_iterator() : count_(0) {}
+    std::size_t count() const { return count_; }
 
-  std::size_t count() const { return count_; }
+    counting_iterator &operator++()
+    {
+      ++count_;
+      return *this;
+    }
 
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
+    counting_iterator operator++(int)
+    {
+      auto it = *this;
+      ++*this;
+      return it;
+    }
 
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
+    value_type operator*() const { return {}; }
+  };
 
-  T& operator*() const { return blackhole_; }
-};
+  template <typename OutputIt> class truncating_iterator_base
+  {
+  protected:
+    OutputIt    out_;
+    std::size_t limit_;
+    std::size_t count_;
 
-template <typename OutputIt> class truncating_iterator_base {
- protected:
-  OutputIt out_;
-  std::size_t limit_;
-  std::size_t count_;
-
-  truncating_iterator_base(OutputIt out, std::size_t limit)
-      : out_(out), limit_(limit), count_(0) {}
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = void;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
-
-  OutputIt base() const { return out_; }
-  std::size_t count() const { return count_; }
-};
+    truncating_iterator_base(OutputIt out, std::size_t limit) : out_(out), limit_(limit), count_(0)
+    {
+    }
 
-// An output iterator that truncates the output and counts the number of objects
-// written to it.
-template <typename OutputIt,
-          typename Enable = typename std::is_void<
-              typename std::iterator_traits<OutputIt>::value_type>::type>
-class truncating_iterator;
+  public:
+    using iterator_category = std::output_iterator_tag;
+    using difference_type   = void;
+    using pointer           = void;
+    using reference         = void;
+    using _Unchecked_type   = truncating_iterator_base; // Mark iterator as checked.
 
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::false_type>
-    : public truncating_iterator_base<OutputIt> {
-  using traits = std::iterator_traits<OutputIt>;
+    OutputIt    base() const { return out_; }
+    std::size_t count() const { return count_; }
+  };
 
-  mutable typename traits::value_type blackhole_;
+  // An output iterator that truncates the output and counts the number of objects
+  // written to it.
+  template <typename OutputIt,
+            typename Enable =
+                typename std::is_void<typename std::iterator_traits<OutputIt>::value_type>::type>
+  class truncating_iterator;
 
- public:
-  using value_type = typename traits::value_type;
+  template <typename OutputIt>
+  class truncating_iterator<OutputIt, std::false_type> : public truncating_iterator_base<OutputIt>
+  {
+    using traits = std::iterator_traits<OutputIt>;
 
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
+    mutable typename traits::value_type blackhole_;
 
-  truncating_iterator& operator++() {
-    if (this->count_++ < this->limit_) ++this->out_;
-    return *this;
-  }
+  public:
+    using value_type = typename traits::value_type;
 
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
+    truncating_iterator(OutputIt out, std::size_t limit)
+        : truncating_iterator_base<OutputIt>(out, limit)
+    {
+    }
 
-  value_type& operator*() const {
-    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
-  }
-};
+    truncating_iterator &operator++()
+    {
+      if (this->count_++ < this->limit_)
+        ++this->out_;
+      return *this;
+    }
 
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::true_type>
-    : public truncating_iterator_base<OutputIt> {
- public:
-  using value_type = typename OutputIt::container_type::value_type;
+    truncating_iterator operator++(int)
+    {
+      auto it = *this;
+      ++*this;
+      return it;
+    }
 
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
+    value_type &operator*() const { return this->count_ < this->limit_ ? *this->out_ : blackhole_; }
+  };
 
-  truncating_iterator& operator=(value_type val) {
-    if (this->count_++ < this->limit_) this->out_ = val;
-    return *this;
-  }
+  template <typename OutputIt>
+  class truncating_iterator<OutputIt, std::true_type> : public truncating_iterator_base<OutputIt>
+  {
+  public:
+    using value_type = typename OutputIt::container_type::value_type;
 
-  truncating_iterator& operator++() { return *this; }
-  truncating_iterator& operator++(int) { return *this; }
-  truncating_iterator& operator*() { return *this; }
-};
+    truncating_iterator(OutputIt out, std::size_t limit)
+        : truncating_iterator_base<OutputIt>(out, limit)
+    {
+    }
 
-// A range with the specified output iterator and value type.
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
-  OutputIt it_;
+    truncating_iterator &operator=(value_type val)
+    {
+      if (this->count_++ < this->limit_)
+        this->out_ = val;
+      return *this;
+    }
 
- public:
-  using value_type = T;
-  using iterator = OutputIt;
-  struct sentinel {};
+    truncating_iterator &operator++() { return *this; }
+    truncating_iterator &operator++(int) { return *this; }
+    truncating_iterator &operator*() { return *this; }
+  };
 
-  explicit output_range(OutputIt it) : it_(it) {}
-  OutputIt begin() const { return it_; }
-  sentinel end() const { return {}; }  // Sentinel is not used yet.
-};
+  // A range with the specified output iterator and value type.
+  template <typename OutputIt, typename T = typename OutputIt::value_type> class output_range
+  {
+  private:
+    OutputIt it_;
+
+  public:
+    using value_type = T;
+    using iterator   = OutputIt;
+    struct sentinel
+    {
+    };
 
-// A range with an iterator appending to a buffer.
-template <typename T>
-class buffer_range
-    : public output_range<std::back_insert_iterator<buffer<T>>, T> {
- public:
-  using iterator = std::back_insert_iterator<buffer<T>>;
-  using output_range<iterator, T>::output_range;
-  buffer_range(buffer<T>& buf)
-      : output_range<iterator, T>(std::back_inserter(buf)) {}
-};
+    explicit output_range(OutputIt it) : it_(it) {}
+    OutputIt begin() const { return it_; }
+    sentinel end() const { return {}; } // Sentinel is not used yet.
+  };
 
-template <typename Char>
-inline size_t count_code_points(basic_string_view<Char> s) {
-  return s.size();
-}
+  template <typename Char> inline size_t count_code_points(basic_string_view<Char> s)
+  {
+    return s.size();
+  }
 
-// Counts the number of code points in a UTF-8 string.
-inline size_t count_code_points(basic_string_view<char8_t> s) {
-  const char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
+  // Counts the number of code points in a UTF-8 string.
+  inline size_t count_code_points(basic_string_view<char8_t> s)
+  {
+    const char8_t *data            = s.data();
+    size_t         num_code_points = 0;
+    for (size_t i = 0, size = s.size(); i != size; ++i) {
+      if ((data[i] & 0xc0) != 0x80)
+        ++num_code_points;
+    }
+    return num_code_points;
   }
-  return num_code_points;
-}
 
-inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
+  inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
 
-template <typename InputIt, typename OutChar>
-using needs_conversion = bool_constant<
-    std::is_same<typename std::iterator_traits<InputIt>::value_type,
-                 char>::value &&
-    std::is_same<OutChar, char8_t>::value>;
+  template <typename InputIt, typename OutChar>
+  using needs_conversion =
+      bool_constant<std::is_same<typename std::iterator_traits<InputIt>::value_type, char>::value &&
+                    std::is_same<OutChar, char8_t>::value>;
 
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::copy(begin, end, it);
-}
+  template <typename OutChar, typename InputIt, typename OutputIt,
+            FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
+  OutputIt copy_str(InputIt begin, InputIt end, OutputIt it)
+  {
+    return std::copy(begin, end, it);
+  }
 
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::transform(begin, end, it, to_char8_t);
-}
+  template <typename OutChar, typename InputIt, typename OutputIt,
+            FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
+  OutputIt copy_str(InputIt begin, InputIt end, OutputIt it)
+  {
+    return std::transform(begin, end, it, to_char8_t);
+  }
 
 #ifndef FMT_USE_GRISU
-#  define FMT_USE_GRISU 0
+#define FMT_USE_GRISU 1
 #endif
 
-template <typename T> constexpr bool use_grisu() {
-  return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
-         sizeof(T) <= sizeof(double);
-}
+  template <typename T> constexpr bool use_grisu()
+  {
+    return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 && sizeof(T) <= sizeof(double);
+  }
+
+  template <typename T> template <typename U> void buffer<T>::append(const U *begin, const U *end)
+  {
+    std::size_t new_size = size_ + to_unsigned(end - begin);
+    reserve(new_size);
+    std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
+    size_ = new_size;
+  }
+} // namespace internal
 
+// A range with an iterator appending to a buffer.
 template <typename T>
-template <typename U>
-void buffer<T>::append(const U* p_begin, const U* p_end) {
-  std::size_t new_size = size_ + to_unsigned(p_end - p_begin);
-  reserve(new_size);
-  std::uninitialized_copy(p_begin, p_end, make_checked(ptr_, capacity_) + size_);
-  size_ = new_size;
-}
-}  // namespace internal
+class buffer_range
+    : public internal::output_range<std::back_insert_iterator<internal::buffer<T>>, T>
+{
+public:
+  using iterator = std::back_insert_iterator<internal::buffer<T>>;
+  using internal::output_range<iterator, T>::output_range;
+  buffer_range(internal::buffer<T> &buf)
+      : internal::output_range<iterator, T>(std::back_inserter(buf))
+  {
+  }
+};
 
 // A UTF-8 string view.
-class u8string_view : public basic_string_view<char8_t> {
- public:
-  u8string_view(const char* s)
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s)) {}
-  u8string_view(const char* s, size_t count) FMT_NOEXCEPT
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s), count) {
+class u8string_view : public basic_string_view<char8_t>
+{
+public:
+  u8string_view(const char *s) : basic_string_view<char8_t>(reinterpret_cast<const char8_t *>(s)) {}
+  u8string_view(const char *s, size_t count) FMT_NOEXCEPT
+      : basic_string_view<char8_t>(reinterpret_cast<const char8_t *>(s), count)
+  {
   }
 };
 
 #if FMT_USE_USER_DEFINED_LITERALS
 inline namespace literals {
-inline u8string_view operator"" _u(const char* s, std::size_t n) {
-  return {s, n};
-}
-}  // namespace literals
+  inline u8string_view operator"" _u(const char *s, std::size_t n) { return {s, n}; }
+} // namespace literals
 #endif
 
 // The number of characters to store in the basic_memory_buffer object itself
@@ -529,43 +550,47 @@ enum { inline_buffer_size = 500 };
   The output can be converted to an ``std::string`` with ``to_string(out)``.
   \endrst
  */
-template <typename T, std::size_t SIZE = inline_buffer_size,
-          typename Allocator = std::allocator<T>>
-class basic_memory_buffer : private Allocator, public internal::buffer<T> {
- private:
+template <typename T, std::size_t SIZE = inline_buffer_size, typename Allocator = std::allocator<T>>
+class basic_memory_buffer : private Allocator, public internal::buffer<T>
+{
+private:
   T store_[SIZE];
 
   // Deallocate memory allocated by the buffer.
-  void deallocate() {
-    T* p_data = this->data();
-    if (p_data != store_) Allocator::deallocate(p_data, this->capacity());
+  void deallocate()
+  {
+    T *data = this->data();
+    if (data != store_)
+      Allocator::deallocate(data, this->capacity());
   }
 
- protected:
+protected:
   void grow(std::size_t size) FMT_OVERRIDE;
 
- public:
-  using value_type = T;
-  using const_reference = const T&;
+public:
+  using value_type      = T;
+  using const_reference = const T &;
 
-  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
-      : Allocator(alloc) {
+  explicit basic_memory_buffer(const Allocator &alloc = Allocator()) : Allocator(alloc)
+  {
     this->set(store_, SIZE);
   }
   ~basic_memory_buffer() { deallocate(); }
 
- private:
+private:
   // Move data from other to this buffer.
-  void move(basic_memory_buffer& other) {
+  void move(basic_memory_buffer &other)
+  {
     Allocator &this_alloc = *this, &other_alloc = other;
-    this_alloc = std::move(other_alloc);
-    T* data = other.data();
+    this_alloc       = std::move(other_alloc);
+    T *         data = other.data();
     std::size_t size = other.size(), capacity = other.capacity();
     if (data == other.store_) {
       this->set(store_, capacity);
       std::uninitialized_copy(other.store_, other.store_ + size,
                               internal::make_checked(store_, capacity));
-    } else {
+    }
+    else {
       this->set(data, capacity);
       // Set pointer to the inline array so that delete is not called
       // when deallocating.
@@ -574,21 +599,22 @@ class basic_memory_buffer : private Allocator, public internal::buffer<T> {
     this->resize(size);
   }
 
- public:
+public:
   /**
     \rst
     Constructs a :class:`fmt::basic_memory_buffer` object moving the content
     of the other object to it.
     \endrst
    */
-  basic_memory_buffer(basic_memory_buffer&& other) { move(other); }
+  basic_memory_buffer(basic_memory_buffer &&other) { move(other); }
 
   /**
     \rst
     Moves the content of the other ``basic_memory_buffer`` object to this one.
     \endrst
    */
-  basic_memory_buffer& operator=(basic_memory_buffer&& other) {
+  basic_memory_buffer &operator=(basic_memory_buffer &&other)
+  {
     assert(this != &other);
     deallocate();
     move(other);
@@ -600,15 +626,18 @@ class basic_memory_buffer : private Allocator, public internal::buffer<T> {
 };
 
 template <typename T, std::size_t SIZE, typename Allocator>
-void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t p_size) {
+void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size)
+{
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (p_size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
+  if (size > 1000)
+    throw std::runtime_error("fuzz mode - won't grow that much");
 #endif
   std::size_t old_capacity = this->capacity();
   std::size_t new_capacity = old_capacity + old_capacity / 2;
-  if (p_size > new_capacity) new_capacity = p_size;
-  T* old_data = this->data();
-  T* new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
+  if (size > new_capacity)
+    new_capacity = size;
+  T *old_data = this->data();
+  T *new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
   // The following code doesn't throw, so the raw pointer above doesn't leak.
   std::uninitialized_copy(old_data, old_data + this->size(),
                           internal::make_checked(new_data, new_capacity));
@@ -616,2004 +645,2151 @@ void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t p_size) {
   // deallocate must not throw according to the standard, but even if it does,
   // the buffer already uses the new storage and will deallocate it in
   // destructor.
-  if (old_data != store_) Allocator::deallocate(old_data, old_capacity);
+  if (old_data != store_)
+    Allocator::deallocate(old_data, old_capacity);
 }
 
-using memory_buffer = basic_memory_buffer<char>;
+using memory_buffer  = basic_memory_buffer<char>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;
 
 /** A formatting error such as invalid format string. */
-class FMT_API format_error : public std::runtime_error {
- public:
-  explicit format_error(const char* message) : std::runtime_error(message) {}
-  explicit format_error(const std::string& message)
-      : std::runtime_error(message) {}
+class FMT_API format_error : public std::runtime_error
+{
+public:
+  explicit format_error(const char *message) : std::runtime_error(message) {}
+  explicit format_error(const std::string &message) : std::runtime_error(message) {}
+  format_error(const format_error &) = default;
+  format_error &operator=(const format_error &) = default;
+  format_error(format_error &&)                 = default;
+  format_error &operator=(format_error &&) = default;
   ~format_error() FMT_NOEXCEPT;
 };
 
 namespace internal {
 
-// Returns true if value is negative, false otherwise.
-// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
-template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T value) {
-  return value < 0;
-}
-template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T) {
-  return false;
-}
-
-// Smallest of uint32_t and uint64_t that is large enough to represent all
-// values of T.
-template <typename T>
-using uint32_or_64_t =
-    conditional_t<std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>;
-
-// Static data is placed in this class template for the header-only config.
-template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
-  static const uint64_t powers_of_10_64[];
-  static const uint32_t zero_or_powers_of_10_32[];
-  static const uint64_t zero_or_powers_of_10_64[];
-  static const uint64_t pow10_significands[];
-  static const int16_t pow10_exponents[];
-  static const char digits[];
-  static const char hex_digits[];
-  static const char foreground_color[];
-  static const char background_color[];
-  static const char reset_color[5];
-  static const wchar_t wreset_color[5];
-};
+  // Returns true if value is negative, false otherwise.
+  // Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
+  template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
+  FMT_CONSTEXPR bool is_negative(T value)
+  {
+    return value < 0;
+  }
+  template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
+  FMT_CONSTEXPR bool is_negative(T)
+  {
+    return false;
+  }
+
+  // Smallest of uint32_t, uint64_t, uint128_t that is large enough to
+  // represent all values of T.
+  template <typename T>
+  using uint32_or_64_or_128_t =
+      conditional_t<std::numeric_limits<T>::digits <= 32, uint32_t,
+                    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
+
+  // Static data is placed in this class template for the header-only config.
+  template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data
+  {
+    static const uint64_t powers_of_10_64[];
+    static const uint32_t zero_or_powers_of_10_32[];
+    static const uint64_t zero_or_powers_of_10_64[];
+    static const uint64_t pow10_significands[];
+    static const int16_t  pow10_exponents[];
+    static const char     digits[];
+    static const char     hex_digits[];
+    static const char     foreground_color[];
+    static const char     background_color[];
+    static const char     reset_color[5];
+    static const wchar_t  wreset_color[5];
+    static const char     signs[];
+  };
 
-FMT_EXTERN template struct basic_data<void>;
+  FMT_EXTERN template struct basic_data<void>;
 
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
+  // This is a struct rather than an alias to avoid shadowing warnings in gcc.
+  struct data : basic_data<>
+  {
+  };
 
 #ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline int count_digits(uint64_t n) {
-  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
-}
+  // Returns the number of decimal digits in n. Leading zeros are not counted
+  // except for n == 0 in which case count_digits returns 1.
+  inline int count_digits(uint64_t n)
+  {
+    // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+    // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
+    int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+    return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
+  }
 #else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline int count_digits(uint64_t n) {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000u;
-    count += 4;
+  // Fallback version of count_digits used when __builtin_clz is not available.
+  inline int count_digits(uint64_t n)
+  {
+    int count = 1;
+    for (;;) {
+      // Integer division is slow so do it for a group of four digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      if (n < 10)
+        return count;
+      if (n < 100)
+        return count + 1;
+      if (n < 1000)
+        return count + 2;
+      if (n < 10000)
+        return count + 3;
+      n /= 10000u;
+      count += 4;
+    }
   }
-}
 #endif
 
-// Counts the number of digits in n. BITS = log2(radix).
-template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
-  int num_digits = 0;
-  do {
-    ++num_digits;
-  } while ((n >>= BITS) != 0);
-  return num_digits;
-}
+#if FMT_USE_INT128
+  inline int count_digits(uint128_t n)
+  {
+    int count = 1;
+    for (;;) {
+      // Integer division is slow so do it for a group of four digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      if (n < 10)
+        return count;
+      if (n < 100)
+        return count + 1;
+      if (n < 1000)
+        return count + 2;
+      if (n < 10000)
+        return count + 3;
+      n /= 10000u;
+      count += 4;
+    }
+  }
+#endif
 
-template <> int count_digits<4>(internal::fallback_uintptr n);
+  // Counts the number of digits in n. BITS = log2(radix).
+  template <unsigned BITS, typename UInt> inline int count_digits(UInt n)
+  {
+    int num_digits = 0;
+    do {
+      ++num_digits;
+    } while ((n >>= BITS) != 0);
+    return num_digits;
+  }
+
+  template <> int count_digits<4>(internal::fallback_uintptr n);
 
 #if FMT_HAS_CPP_ATTRIBUTE(always_inline)
-#  define FMT_ALWAYS_INLINE __attribute__((always_inline))
+#define FMT_ALWAYS_INLINE __attribute__((always_inline))
 #else
-#  define FMT_ALWAYS_INLINE
+#define FMT_ALWAYS_INLINE
 #endif
 
-template <typename Handler>
-inline char* lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
-
-// Computes g = floor(log10(n)) and calls h.on<g>(n);
-template <typename Handler> inline char* lg(uint32_t n, Handler h) {
-  return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
-                 : n < 1000000
-                       ? n < 10000 ? n < 1000 ? h.template on<2>(n)
-                                              : h.template on<3>(n)
-                                   : n < 100000 ? h.template on<4>(n)
-                                                : h.template on<5>(n)
-                       : n < 100000000 ? n < 10000000 ? h.template on<6>(n)
-                                                      : h.template on<7>(n)
-                                       : n < 1000000000 ? h.template on<8>(n)
-                                                        : h.template on<9>(n);
-}
+  template <typename Handler> inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
+
+  // Computes g = floor(log10(n)) and calls h.on<g>(n);
+  template <typename Handler> inline char *lg(uint32_t n, Handler h)
+  {
+    return n < 100
+               ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
+               : n < 1000000
+                     ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n)
+                                 : n < 100000 ? h.template on<4>(n) : h.template on<5>(n)
+                     : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n)
+                                     : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n);
+  }
+
+  // An lg handler that formats a decimal number.
+  // Usage: lg(n, decimal_formatter(buffer));
+  class decimal_formatter
+  {
+  private:
+    char *buffer_;
+
+    void write_pair(unsigned N, uint32_t index)
+    {
+      std::memcpy(buffer_ + N, data::digits + index * 2, 2);
+    }
+
+  public:
+    explicit decimal_formatter(char *buf) : buffer_(buf) {}
 
-// An lg handler that formats a decimal number.
-// Usage: lg(n, decimal_formatter(buffer));
-class decimal_formatter {
- private:
-  char* buffer_;
-
-  void write_pair(unsigned N, uint32_t index) {
-    std::memcpy(buffer_ + N, data::digits + index * 2, 2);
-  }
-
- public:
-  explicit decimal_formatter(char* buf) : buffer_(buf) {}
-
-  template <unsigned N> char* on(uint32_t u) {
-    if (N == 0) {
-      *buffer_ = static_cast<char>(u) + '0';
-    } else if (N == 1) {
-      write_pair(0, u);
-    } else {
-      // The idea of using 4.32 fixed-point numbers is based on
-      // https://github.com/jeaiii/itoa
-      unsigned n = N - 1;
-      unsigned a = n / 5 * n * 53 / 16;
-      uint64_t t =
-          ((1ULL << (32 + a)) / data::zero_or_powers_of_10_32[n] + 1 - n / 9);
-      t = ((t * u) >> a) + n / 5 * 4;
-      write_pair(0, t >> 32);
-      for (unsigned i = 2; i < N; i += 2) {
-        t = 100ULL * static_cast<uint32_t>(t);
-        write_pair(i, t >> 32);
+    template <unsigned N> char *on(uint32_t u)
+    {
+      if (N == 0) {
+        *buffer_ = static_cast<char>(u) + '0';
+      }
+      else if (N == 1) {
+        write_pair(0, u);
       }
-      if (N % 2 == 0) {
-        buffer_[N] =
-            static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
+      else {
+        // The idea of using 4.32 fixed-point numbers is based on
+        // https://github.com/jeaiii/itoa
+        unsigned n = N - 1;
+        unsigned a = n / 5 * n * 53 / 16;
+        uint64_t t = ((1ULL << (32 + a)) / data::zero_or_powers_of_10_32[n] + 1 - n / 9);
+        t          = ((t * u) >> a) + n / 5 * 4;
+        write_pair(0, t >> 32);
+        for (unsigned i = 2; i < N; i += 2) {
+          t = 100ULL * static_cast<uint32_t>(t);
+          write_pair(i, t >> 32);
+        }
+        if (N % 2 == 0) {
+          buffer_[N] = static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
+        }
       }
+      return buffer_ += N + 1;
     }
-    return buffer_ += N + 1;
-  }
-};
+  };
 
 #ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline int count_digits(uint32_t n) {
-  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
-}
+  // Optional version of count_digits for better performance on 32-bit platforms.
+  inline int count_digits(uint32_t n)
+  {
+    int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+    return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
+  }
 #endif
 
-template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
-template <typename Char> inline Char thousands_sep(locale_ref loc) {
-  return Char(thousands_sep_impl<char>(loc));
-}
-template <> inline wchar_t thousands_sep(locale_ref loc) {
-  return thousands_sep_impl<wchar_t>(loc);
-}
+  template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
+  template <typename Char> inline Char  thousands_sep(locale_ref loc)
+  {
+    return Char(thousands_sep_impl<char>(loc));
+  }
+  template <> inline wchar_t thousands_sep(locale_ref loc)
+  {
+    return thousands_sep_impl<wchar_t>(loc);
+  }
 
-template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
-template <typename Char> inline Char decimal_point(locale_ref loc) {
-  return Char(decimal_point_impl<char>(loc));
-}
-template <> inline wchar_t decimal_point(locale_ref loc) {
-  return decimal_point_impl<wchar_t>(loc);
-}
+  template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
+  template <typename Char> inline Char  decimal_point(locale_ref loc)
+  {
+    return Char(decimal_point_impl<char>(loc));
+  }
+  template <> inline wchar_t decimal_point(locale_ref loc)
+  {
+    return decimal_point_impl<wchar_t>(loc);
+  }
 
-// Formats a decimal unsigned integer value writing into buffer.
-// add_thousands_sep is called after writing each char to add a thousands
-// separator if necessary.
-template <typename UInt, typename Char, typename F>
-inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
-                            F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  buffer += num_digits;
-  Char* end = buffer;
-  while (value >= 100) {
-    // Integer division is slow so do it for a group of two digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    unsigned index = static_cast<unsigned>((value % 100) * 2);
-    value /= 100;
-    *--buffer = static_cast<Char>(data::digits[index + 1]);
+  // Formats a decimal unsigned integer value writing into buffer.
+  // add_thousands_sep is called after writing each char to add a thousands
+  // separator if necessary.
+  template <typename UInt, typename Char, typename F>
+  inline Char *format_decimal(Char *buffer, UInt value, int num_digits, F add_thousands_sep)
+  {
+    FMT_ASSERT(num_digits >= 0, "invalid digit count");
+    buffer += num_digits;
+    Char *end = buffer;
+    while (value >= 100) {
+      // Integer division is slow so do it for a group of two digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      unsigned index = static_cast<unsigned>((value % 100) * 2);
+      value /= 100;
+      *--buffer = static_cast<Char>(data::digits[index + 1]);
+      add_thousands_sep(buffer);
+      *--buffer = static_cast<Char>(data::digits[index]);
+      add_thousands_sep(buffer);
+    }
+    if (value < 10) {
+      *--buffer = static_cast<Char>('0' + value);
+      return end;
+    }
+    unsigned index = static_cast<unsigned>(value * 2);
+    *--buffer      = static_cast<Char>(data::digits[index + 1]);
     add_thousands_sep(buffer);
     *--buffer = static_cast<Char>(data::digits[index]);
-    add_thousands_sep(buffer);
-  }
-  if (value < 10) {
-    *--buffer = static_cast<Char>('0' + value);
     return end;
   }
-  unsigned index = static_cast<unsigned>(value * 2);
-  *--buffer = static_cast<Char>(data::digits[index + 1]);
-  add_thousands_sep(buffer);
-  *--buffer = static_cast<Char>(data::digits[index]);
-  return end;
-}
-
-template <typename Char, typename UInt, typename Iterator, typename F>
-inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
-                               F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  // Buffer should be large enough to hold all digits (<= digits10 + 1).
-  enum { max_size = std::numeric_limits<UInt>::digits10 + 1 };
-  Char buffer[max_size + max_size / 3];
-  auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
-  return internal::copy_str<Char>(buffer, end, out);
-}
-
-template <typename Char, typename It, typename UInt>
-inline It format_decimal(It out, UInt value, int num_digits) {
-  return format_decimal<Char>(out, value, num_digits, [](Char*) {});
-}
 
-template <unsigned BASE_BITS, typename Char, typename UInt>
-inline Char* format_uint(Char* buffer, UInt value, int num_digits,
-                         bool upper = false) {
-  buffer += num_digits;
-  Char* end = buffer;
-  do {
-    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
-    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
-                                                : digits[digit]);
-  } while ((value >>= BASE_BITS) != 0);
-  return end;
-}
+  template <typename Int> constexpr int digits10() noexcept
+  {
+    return std::numeric_limits<Int>::digits10;
+  }
+  template <> constexpr int digits10<int128_t>() noexcept { return 38; }
+  template <> constexpr int digits10<uint128_t>() noexcept { return 38; }
+
+  template <typename Char, typename UInt, typename Iterator, typename F>
+  inline Iterator format_decimal(Iterator out, UInt value, int num_digits, F add_thousands_sep)
+  {
+    FMT_ASSERT(num_digits >= 0, "invalid digit count");
+    // Buffer should be large enough to hold all digits (<= digits10 + 1).
+    enum { max_size = digits10<UInt>() + 1 };
+    Char buffer[max_size + max_size / 3];
+    auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
+    return internal::copy_str<Char>(buffer, end, out);
+  }
+
+  template <typename Char, typename It, typename UInt>
+  inline It format_decimal(It out, UInt value, int num_digits)
+  {
+    return format_decimal<Char>(out, value, num_digits, [](Char *) {});
+  }
+
+  template <unsigned BASE_BITS, typename Char, typename UInt>
+  inline Char *format_uint(Char *buffer, UInt value, int num_digits, bool upper = false)
+  {
+    buffer += num_digits;
+    Char *end = buffer;
+    do {
+      const char *digits = upper ? "0123456789ABCDEF" : data::hex_digits;
+      unsigned    digit  = (value & ((1 << BASE_BITS) - 1));
+      *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
+    } while ((value >>= BASE_BITS) != 0);
+    return end;
+  }
 
-template <unsigned BASE_BITS, typename Char>
-Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,
-                  bool = false) {
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  int start = (num_digits + char_digits - 1) / char_digits - 1;
-  if (int start_digits = num_digits % char_digits) {
-    unsigned value = n.value[start--];
-    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
-  }
-  for (; start >= 0; --start) {
-    unsigned value = n.value[start];
-    buffer += char_digits;
-    auto p = buffer;
-    for (int i = 0; i < char_digits; ++i) {
-      unsigned digit = (value & ((1 << BASE_BITS) - 1));
-      *--p = static_cast<Char>(data::hex_digits[digit]);
-      value >>= BASE_BITS;
-    }
-  }
-  return buffer;
-}
+  template <unsigned BASE_BITS, typename Char>
+  Char *format_uint(Char *buffer, internal::fallback_uintptr n, int num_digits, bool = false)
+  {
+    auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+    int  start       = (num_digits + char_digits - 1) / char_digits - 1;
+    if (int start_digits = num_digits % char_digits) {
+      unsigned value = n.value[start--];
+      buffer         = format_uint<BASE_BITS>(buffer, value, start_digits);
+    }
+    for (; start >= 0; --start) {
+      unsigned value = n.value[start];
+      buffer += char_digits;
+      auto p = buffer;
+      for (int i = 0; i < char_digits; ++i) {
+        unsigned digit = (value & ((1 << BASE_BITS) - 1));
+        *--p           = static_cast<Char>(data::hex_digits[digit]);
+        value >>= BASE_BITS;
+      }
+    }
+    return buffer;
+  }
 
-template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
-inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
-  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 1];
-  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return internal::copy_str<Char>(buffer, buffer + num_digits, out);
-}
+  template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
+  inline It format_uint(It out, UInt value, int num_digits, bool upper = false)
+  {
+    // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
+    char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 1];
+    format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+    return internal::copy_str<Char>(buffer, buffer + num_digits, out);
+  }
 
 #ifndef _WIN32
-#  define FMT_USE_WINDOWS_H 0
+#define FMT_USE_WINDOWS_H 0
 #elif !defined(FMT_USE_WINDOWS_H)
-#  define FMT_USE_WINDOWS_H 1
+#define FMT_USE_WINDOWS_H 1
 #endif
 
 // Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
 // All the functionality that relies on it will be disabled too.
 #if FMT_USE_WINDOWS_H
-// A converter from UTF-8 to UTF-16.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class utf8_to_utf16 {
- private:
-  wmemory_buffer buffer_;
-
- public:
-  FMT_API explicit utf8_to_utf16(string_view s);
-  operator wstring_view() const { return wstring_view(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const wchar_t* c_str() const { return &buffer_[0]; }
-  std::wstring str() const { return std::wstring(&buffer_[0], size()); }
-};
+  // A converter from UTF-8 to UTF-16.
+  // It is only provided for Windows since other systems support UTF-8 natively.
+  class utf8_to_utf16
+  {
+  private:
+    wmemory_buffer buffer_;
+
+  public:
+    FMT_API explicit utf8_to_utf16(string_view s);
+                   operator wstring_view() const { return wstring_view(&buffer_[0], size()); }
+    size_t         size() const { return buffer_.size() - 1; }
+    const wchar_t *c_str() const { return &buffer_[0]; }
+    std::wstring   str() const { return std::wstring(&buffer_[0], size()); }
+  };
 
-// A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class utf16_to_utf8 {
- private:
-  memory_buffer buffer_;
-
- public:
-  utf16_to_utf8() {}
-  FMT_API explicit utf16_to_utf8(wstring_view s);
-  operator string_view() const { return string_view(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const char* c_str() const { return &buffer_[0]; }
-  std::string str() const { return std::string(&buffer_[0], size()); }
-
-  // Performs conversion returning a system error code instead of
-  // throwing exception on conversion error. This method may still throw
-  // in case of memory allocation error.
-  FMT_API int convert(wstring_view s);
-};
+  // A converter from UTF-16 to UTF-8.
+  // It is only provided for Windows since other systems support UTF-8 natively.
+  class utf16_to_utf8
+  {
+  private:
+    memory_buffer buffer_;
+
+  public:
+    utf16_to_utf8() {}
+    FMT_API explicit utf16_to_utf8(wstring_view s);
+                operator string_view() const { return string_view(&buffer_[0], size()); }
+    size_t      size() const { return buffer_.size() - 1; }
+    const char *c_str() const { return &buffer_[0]; }
+    std::string str() const { return std::string(&buffer_[0], size()); }
+
+    // Performs conversion returning a system error code instead of
+    // throwing exception on conversion error. This method may still throw
+    // in case of memory allocation error.
+    FMT_API int convert(wstring_view s);
+  };
 
-FMT_API void format_windows_error(fmt::internal::buffer<char>& out,
-                                  int error_code,
-                                  fmt::string_view message) FMT_NOEXCEPT;
+  FMT_API void format_windows_error(fmt::internal::buffer<char> &out, int error_code,
+                                    fmt::string_view message) FMT_NOEXCEPT;
 #endif
 
-template <typename T = void> struct null {};
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  Char data_[6];
-
- public:
-  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
-  FMT_CONSTEXPR const Char& operator[](size_t index) const {
-    return data_[index];
-  }
+  template <typename T = void> struct null
+  {
+  };
 
-  static FMT_CONSTEXPR fill_t<Char> make() {
-    auto fill = fill_t<Char>();
-    fill[0] = Char(' ');
-    return fill;
-  }
-};
-}  // namespace internal
+  // Workaround an array initialization issue in gcc 4.8.
+  template <typename Char> struct fill_t
+  {
+  private:
+    Char data_[6];
+
+  public:
+    FMT_CONSTEXPR Char &operator[](size_t index) { return data_[index]; }
+    FMT_CONSTEXPR const Char &operator[](size_t index) const { return data_[index]; }
+
+    static FMT_CONSTEXPR fill_t<Char> make()
+    {
+      auto fill = fill_t<Char>();
+      fill[0]   = Char(' ');
+      return fill;
+    }
+  };
+} // namespace internal
 
 // We cannot use enum classes as bit fields because of a gcc bug
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
 namespace align {
-enum type { none, left, right, center, numeric };
+  enum type { none, left, right, center, numeric };
 }
 using align_t = align::type;
 
 namespace sign {
-enum type { none, minus, plus, space };
+  enum type { none, minus, plus, space };
 }
 using sign_t = sign::type;
 
 // Format specifiers for built-in and string types.
-template <typename Char> struct basic_format_specs {
-  int width;
-  int precision;
-  char type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
+template <typename Char> struct basic_format_specs
+{
+  int                    width;
+  int                    precision;
+  char                   type;
+  align_t                align : 4;
+  sign_t                 sign : 3;
+  bool                   alt : 1; // Alternate form ('#').
   internal::fill_t<Char> fill;
 
   constexpr basic_format_specs()
-      : width(0),
-        precision(-1),
-        type(0),
-        align(align::none),
-        sign(sign::none),
-        alt(false),
-        fill(internal::fill_t<Char>::make()) {}
+      : width(0), precision(-1), type(0), align(align::none), sign(sign::none), alt(false),
+        fill(internal::fill_t<Char>::make())
+  {
+  }
 };
 
 using format_specs = basic_format_specs<char>;
 
 namespace internal {
 
-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Char, typename It> It write_exponent(int exp, It it) {
-  FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
-  if (exp < 0) {
-    *it++ = static_cast<Char>('-');
-    exp = -exp;
-  } else {
-    *it++ = static_cast<Char>('+');
-  }
-  if (exp >= 100) {
-    *it++ = static_cast<Char>(static_cast<char>('0' + exp / 100));
-    exp %= 100;
-  }
-  const char* d = data::digits + exp * 2;
-  *it++ = static_cast<Char>(d[0]);
-  *it++ = static_cast<Char>(d[1]);
-  return it;
-}
+  struct gen_digits_params
+  {
+    int    num_digits;
+    sign_t sign : 3;
+    bool   fixed;
+    bool   upper;
+    bool   trailing_zeros;
+  };
 
-struct gen_digits_params {
-  int num_digits;
-  bool fixed;
-  bool upper;
-  bool trailing_zeros;
-};
+  // Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
+  template <typename Char, typename It> It write_exponent(int exp, It it)
+  {
+    FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
+    if (exp < 0) {
+      *it++ = static_cast<Char>('-');
+      exp   = -exp;
+    }
+    else {
+      *it++ = static_cast<Char>('+');
+    }
+    if (exp >= 100) {
+      *it++ = static_cast<Char>(static_cast<char>('0' + exp / 100));
+      exp %= 100;
+    }
+    const char *d = data::digits + exp * 2;
+    *it++         = static_cast<Char>(d[0]);
+    *it++         = static_cast<Char>(d[1]);
+    return it;
+  }
 
-// The number is given as v = digits * pow(10, exp).
-template <typename Char, typename It>
-It grisu_prettify(const char* digits, int size, int exp, It it,
-                  gen_digits_params params, Char decimal_point) {
-  // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
-  int full_exp = size + exp;
-  if (!params.fixed) {
-    // Insert a decimal point after the first digit and add an exponent.
-    *it++ = static_cast<Char>(*digits);
-    if (size > 1) *it++ = decimal_point;
-    exp += size - 1;
-    it = copy_str<Char>(digits + 1, digits + size, it);
-    if (size < params.num_digits)
-      it = std::fill_n(it, params.num_digits - size, static_cast<Char>('0'));
-    *it++ = static_cast<Char>(params.upper ? 'E' : 'e');
-    return write_exponent<Char>(exp, it);
-  }
-  if (size <= full_exp) {
-    // 1234e7 -> 12340000000[.0+]
-    it = copy_str<Char>(digits, digits + size, it);
-    it = std::fill_n(it, full_exp - size, static_cast<Char>('0'));
-    int num_zeros = (std::max)(params.num_digits - full_exp, 1);
-    if (params.trailing_zeros) {
-      *it++ = decimal_point;
+  template <typename Char> class grisu_writer
+  {
+  private:
+    // The number is given as v = digits_ * pow(10, exp_).
+    const char *      digits_;
+    int               num_digits_;
+    int               exp_;
+    size_t            size_;
+    gen_digits_params params_;
+    Char              decimal_point_;
+
+    template <typename It> It grisu_prettify(It it) const
+    {
+      // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
+      int full_exp = num_digits_ + exp_;
+      if (!params_.fixed) {
+        // Insert a decimal point after the first digit and add an exponent.
+        *it++ = static_cast<Char>(*digits_);
+        if (num_digits_ > 1)
+          *it++ = decimal_point_;
+        it    = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
+        *it++ = static_cast<Char>(params_.upper ? 'E' : 'e');
+        return write_exponent<Char>(full_exp - 1, it);
+      }
+      if (num_digits_ <= full_exp) {
+        // 1234e7 -> 12340000000[.0+]
+        it            = copy_str<Char>(digits_, digits_ + num_digits_, it);
+        it            = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
+        int num_zeros = (std::max)(params_.num_digits - full_exp, 1);
+        if (params_.trailing_zeros) {
+          *it++ = decimal_point_;
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-      if (num_zeros > 1000)
-        throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
+          if (num_zeros > 1000)
+            throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
 #endif
-      it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-    }
-  } else if (full_exp > 0) {
-    // 1234e-2 -> 12.34[0+]
-    it = copy_str<Char>(digits, digits + full_exp, it);
-    if (!params.trailing_zeros) {
-      // Remove trailing zeros.
-      while (size > full_exp && digits[size - 1] == '0') --size;
-      if (size != full_exp) *it++ = decimal_point;
-      return copy_str<Char>(digits + full_exp, digits + size, it);
-    }
-    *it++ = decimal_point;
-    it = copy_str<Char>(digits + full_exp, digits + size, it);
-    if (params.num_digits > size) {
-      // Add trailing zeros.
-      int num_zeros = params.num_digits - size;
-      it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-    }
-  } else {
-    // 1234e-6 -> 0.001234
-    *it++ = static_cast<Char>('0');
-    int num_zeros = -full_exp;
-    if (params.num_digits >= 0 && params.num_digits < num_zeros)
-      num_zeros = params.num_digits;
-    if (!params.trailing_zeros)
-      while (size > 0 && digits[size - 1] == '0') --size;
-    if (num_zeros != 0 || size != 0) {
-      *it++ = decimal_point;
-      it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      it = copy_str<Char>(digits, digits + size, it);
-    }
-  }
-  return it;
-}
-
-namespace grisu_options {
-enum { fixed = 1, grisu3 = 2 };
-}
-
-// Formats value using the Grisu algorithm:
-// https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf
-template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
-FMT_API bool grisu_format(Double, buffer<char>&, int, unsigned, int&);
-template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
-inline bool grisu_format(Double, buffer<char>&, int, unsigned, int&) {
-  return false;
-}
+          it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+        }
+      }
+      else if (full_exp > 0) {
+        // 1234e-2 -> 12.34[0+]
+        it = copy_str<Char>(digits_, digits_ + full_exp, it);
+        if (!params_.trailing_zeros) {
+          // Remove trailing zeros.
+          int num_digits = num_digits_;
+          while (num_digits > full_exp && digits_[num_digits - 1] == '0')
+            --num_digits;
+          if (num_digits != full_exp)
+            *it++ = decimal_point_;
+          return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
+        }
+        *it++ = decimal_point_;
+        it    = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
+        if (params_.num_digits > num_digits_) {
+          // Add trailing zeros.
+          int num_zeros = params_.num_digits - num_digits_;
+          it            = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+        }
+      }
+      else {
+        // 1234e-6 -> 0.001234
+        *it++         = static_cast<Char>('0');
+        int num_zeros = -full_exp;
+        if (params_.num_digits >= 0 && params_.num_digits < num_zeros)
+          num_zeros = params_.num_digits;
+        int num_digits = num_digits_;
+        if (!params_.trailing_zeros)
+          while (num_digits > 0 && digits_[num_digits - 1] == '0')
+            --num_digits;
+        if (num_zeros != 0 || num_digits != 0) {
+          *it++ = decimal_point_;
+          it    = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+          it    = copy_str<Char>(digits_, digits_ + num_digits, it);
+        }
+      }
+      return it;
+    }
 
-struct sprintf_specs {
-  int precision;
-  char type;
-  bool alt : 1;
+  public:
+    grisu_writer(const char *digits, int num_digits, int exp, gen_digits_params params,
+                 Char decimal_point)
+        : digits_(digits), num_digits_(num_digits), exp_(exp), params_(params),
+          decimal_point_(decimal_point)
+    {
+      int full_exp  = num_digits + exp - 1;
+      int precision = params.num_digits > 0 ? params.num_digits : 16;
+      params_.fixed |= full_exp >= -4 && full_exp < precision;
+      size_ = grisu_prettify(counting_iterator()).count();
+      size_ += params_.sign ? 1 : 0;
+    }
 
-  template <typename Char>
-  constexpr sprintf_specs(basic_format_specs<Char> specs)
-      : precision(specs.precision), type(specs.type), alt(specs.alt) {}
+    size_t size() const { return size_; }
+    size_t width() const { return size(); }
 
-  constexpr bool has_precision() const { return precision >= 0; }
-};
+    template <typename It> void operator()(It &&it)
+    {
+      if (params_.sign)
+        *it++ = static_cast<Char>(data::signs[params_.sign]);
+      it = grisu_prettify(it);
+    }
+  };
 
-template <typename Double>
-char* sprintf_format(Double, internal::buffer<char>&, sprintf_specs);
-
-template <typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
-  case 0:
-  case 'd':
-    handler.on_dec();
-    break;
-  case 'x':
-  case 'X':
-    handler.on_hex();
-    break;
-  case 'b':
-  case 'B':
-    handler.on_bin();
-    break;
-  case 'o':
-    handler.on_oct();
-    break;
-  case 'n':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error();
+  namespace grisu_options {
+    enum { fixed = 1, grisu2 = 2, binary32 = 4 };
   }
-}
 
-template <typename Handler>
-FMT_CONSTEXPR void handle_float_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
-  case 0:
-  case 'g':
-  case 'G':
-    handler.on_general();
-    break;
-  case 'e':
-  case 'E':
-    handler.on_exp();
-    break;
-  case 'f':
-  case 'F':
-    handler.on_fixed();
-    break;
-  case '%':
-    handler.on_percent();
-    break;
-  case 'a':
-  case 'A':
-    handler.on_hex();
-    break;
-  case 'n':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error();
-    break;
+  // Formats value using the Grisu algorithm:
+  // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf
+  template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
+  FMT_API bool grisu_format(Double, buffer<char> &, int, unsigned, int &);
+  template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
+  inline bool grisu_format(Double, buffer<char> &, int, unsigned, int &)
+  {
+    return false;
   }
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
-                                     Handler&& handler) {
-  if (!specs) return handler.on_char();
-  if (specs->type && specs->type != 'c') return handler.on_int();
-  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
-    handler.on_error("invalid format specifier for char");
-  handler.on_char();
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
-  if (spec == 0 || spec == 's')
-    handler.on_string();
-  else if (spec == 'p')
-    handler.on_pointer();
-  else
-    handler.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
-}
 
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
-}
+  struct sprintf_specs
+  {
+    int  precision;
+    char type;
+    bool alt : 1;
 
-template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
+    template <typename Char>
+    constexpr sprintf_specs(basic_format_specs<Char> specs)
+        : precision(specs.precision), type(specs.type), alt(specs.alt)
+    {
+    }
 
-  FMT_CONSTEXPR void on_dec() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_bin() {}
-  FMT_CONSTEXPR void on_oct() {}
-  FMT_CONSTEXPR void on_num() {}
+    constexpr bool has_precision() const { return precision >= 0; }
+  };
 
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
+  template <typename Double> char *sprintf_format(Double, internal::buffer<char> &, sprintf_specs);
+
+  template <>
+  inline char *sprintf_format<float>(float value, internal::buffer<char> &buf, sprintf_specs specs)
+  {
+    // printf does not have a float format specifier, it only supports double.
+    return sprintf_format<double>(value, buf, specs);
+  }
+
+  template <typename Handler> FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler &&handler)
+  {
+    switch (spec) {
+    case 0:
+    case 'd': handler.on_dec(); break;
+    case 'x':
+    case 'X': handler.on_hex(); break;
+    case 'b':
+    case 'B': handler.on_bin(); break;
+    case 'o': handler.on_oct(); break;
+    case 'n': handler.on_num(); break;
+    default: handler.on_error();
+    }
   }
-};
-
-template <typename ErrorHandler>
-class float_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_general() {}
-  FMT_CONSTEXPR void on_exp() {}
-  FMT_CONSTEXPR void on_fixed() {}
-  FMT_CONSTEXPR void on_percent() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_num() {}
 
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
+  template <typename Handler>
+  FMT_CONSTEXPR void handle_float_type_spec(char spec, Handler &&handler)
+  {
+    switch (spec) {
+    case 0:
+    case 'g':
+    case 'G': handler.on_general(); break;
+    case 'e':
+    case 'E': handler.on_exp(); break;
+    case 'f':
+    case 'F': handler.on_fixed(); break;
+    case '%': handler.on_percent(); break;
+    case 'a':
+    case 'A': handler.on_hex(); break;
+    case 'n': handler.on_num(); break;
+    default: handler.on_error(); break;
+    }
   }
-};
 
-template <typename ErrorHandler>
-class char_specs_checker : public ErrorHandler {
- private:
-  char type_;
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char> *specs, Handler &&handler)
+  {
+    if (!specs)
+      return handler.on_char();
+    if (specs->type && specs->type != 'c')
+      return handler.on_int();
+    if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
+      handler.on_error("invalid format specifier for char");
+    handler.on_char();
+  }
+
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler)
+  {
+    if (spec == 0 || spec == 's')
+      handler.on_string();
+    else if (spec == 'p')
+      handler.on_pointer();
+    else
+      handler.on_error("invalid type specifier");
+  }
 
- public:
-  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
-      : ErrorHandler(eh), type_(type) {}
+  template <typename Char, typename ErrorHandler>
+  FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh)
+  {
+    if (spec != 0 && spec != 's')
+      eh.on_error("invalid type specifier");
+  }
 
-  FMT_CONSTEXPR void on_int() {
-    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
+  template <typename Char, typename ErrorHandler>
+  FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh)
+  {
+    if (spec != 0 && spec != 'p')
+      eh.on_error("invalid type specifier");
   }
-  FMT_CONSTEXPR void on_char() {}
-};
 
-template <typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
+  template <typename ErrorHandler> class int_type_checker : private ErrorHandler
+  {
+  public:
+    FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
-  FMT_CONSTEXPR void on_string() {}
-  FMT_CONSTEXPR void on_pointer() {}
-};
+    FMT_CONSTEXPR void on_dec() {}
+    FMT_CONSTEXPR void on_hex() {}
+    FMT_CONSTEXPR void on_bin() {}
+    FMT_CONSTEXPR void on_oct() {}
+    FMT_CONSTEXPR void on_num() {}
 
-template <typename Context>
-void arg_map<Context>::init(const basic_format_args<Context>& args) {
-  if (map_) return;
-  map_ = new entry[internal::to_unsigned(args.max_size())];
-  if (args.is_packed()) {
-    for (int i = 0;; ++i) {
-      internal::type arg_type = args.type(i);
-      if (arg_type == internal::none_type) return;
-      if (arg_type == internal::named_arg_type) push_back(args.values_[i]);
-    }
-  }
-  for (int i = 0, n = args.max_size(); i < n; ++i) {
-    auto type = args.args_[i].type_;
-    if (type == internal::named_arg_type) push_back(args.args_[i].value_);
-  }
-}
+    FMT_CONSTEXPR void on_error() { ErrorHandler::on_error("invalid type specifier"); }
+  };
 
-// This template provides operations for formatting and writing data into a
-// character range.
-template <typename Range> class basic_writer {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
+  template <typename ErrorHandler> class float_type_checker : private ErrorHandler
+  {
+  public:
+    FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
- private:
-  iterator out_;  // Output iterator.
-  internal::locale_ref locale_;
+    FMT_CONSTEXPR void on_general() {}
+    FMT_CONSTEXPR void on_exp() {}
+    FMT_CONSTEXPR void on_fixed() {}
+    FMT_CONSTEXPR void on_percent() {}
+    FMT_CONSTEXPR void on_hex() {}
+    FMT_CONSTEXPR void on_num() {}
 
-  // Attempts to reserve space for n extra characters in the output range.
-  // Returns a pointer to the reserved range or a reference to out_.
-  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
-    return internal::reserve(out_, n);
-  }
+    FMT_CONSTEXPR void on_error() { ErrorHandler::on_error("invalid type specifier"); }
+  };
 
-  template <typename F> struct padded_int_writer {
-    size_t size_;
-    string_view prefix;
-    char_type fill;
-    std::size_t padding;
-    F f;
+  template <typename ErrorHandler> class char_specs_checker : public ErrorHandler
+  {
+  private:
+    char type_;
 
-    size_t size() const { return size_; }
-    size_t width() const { return size_; }
+  public:
+    FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh) : ErrorHandler(eh), type_(type) {}
 
-    template <typename It> void operator()(It&& it) const {
-      if (prefix.size() != 0)
-        it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
-      it = std::fill_n(it, padding, fill);
-      f(it);
+    FMT_CONSTEXPR void on_int()
+    {
+      handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
     }
+    FMT_CONSTEXPR void on_char() {}
   };
 
-  // Writes an integer in the format
-  //   <left-padding><prefix><numeric-padding><digits><right-padding>
-  // where <digits> are written by f(it).
-  template <typename F>
-  void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
-    std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
-    char_type fill = specs.fill[0];
-    std::size_t padding = 0;
-    if (specs.align == align::numeric) {
-      auto unsiged_width = internal::to_unsigned(specs.width);
-      if (unsiged_width > size) {
-        padding = unsiged_width - size;
-        size = unsiged_width;
-      }
-    } else if (specs.precision > num_digits) {
-      size = prefix.size() + internal::to_unsigned(specs.precision);
-      padding = internal::to_unsigned(specs.precision - num_digits);
-      fill = static_cast<char_type>('0');
-    }
-    if (specs.align == align::none) specs.align = align::right;
-    write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
-  }
-
-  // Writes a decimal integer.
-  template <typename Int> void write_decimal(Int value) {
-    auto abs_value = static_cast<uint32_or_64_t<Int>>(value);
-    bool is_negative = internal::is_negative(value);
-    if (is_negative) abs_value = 0 - abs_value;
-    int num_digits = internal::count_digits(abs_value);
-    auto&& it =
-        reserve((is_negative ? 1 : 0) + static_cast<size_t>(num_digits));
-    if (is_negative) *it++ = static_cast<char_type>('-');
-    it = internal::format_decimal<char_type>(it, abs_value, num_digits);
-  }
-
-  // The handle_int_type_spec handler that writes an integer.
-  template <typename Int, typename Specs> struct int_writer {
-    using unsigned_type = uint32_or_64_t<Int>;
-
-    basic_writer<Range>& writer;
-    const Specs& specs;
-    unsigned_type abs_value;
-    char prefix[4];
-    unsigned prefix_size;
-
-    string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
-    int_writer(basic_writer<Range>& w, Int value, const Specs& s)
-        : writer(w),
-          specs(s),
-          abs_value(static_cast<unsigned_type>(value)),
-          prefix_size(0) {
-      if (internal::is_negative(value)) {
-        prefix[0] = '-';
-        ++prefix_size;
-        abs_value = 0 - abs_value;
-      } else if (specs.sign != sign::none && specs.sign != sign::minus) {
-        prefix[0] = specs.sign == sign::plus ? '+' : ' ';
-        ++prefix_size;
-      }
-    }
+  template <typename ErrorHandler> class cstring_type_checker : public ErrorHandler
+  {
+  public:
+    FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
-    struct dec_writer {
-      unsigned_type abs_value;
-      int num_digits;
+    FMT_CONSTEXPR void on_string() {}
+    FMT_CONSTEXPR void on_pointer() {}
+  };
 
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+  template <typename Context> void arg_map<Context>::init(const basic_format_args<Context> &args)
+  {
+    if (map_)
+      return;
+    map_ = new entry[internal::to_unsigned(args.max_size())];
+    if (args.is_packed()) {
+      for (int i = 0;; ++i) {
+        internal::type arg_type = args.type(i);
+        if (arg_type == internal::none_type)
+          return;
+        if (arg_type == internal::named_arg_type)
+          push_back(args.values_[i]);
       }
-    };
-
-    void on_dec() {
-      int num_digits = internal::count_digits(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       dec_writer{abs_value, num_digits});
     }
+    for (int i = 0, n = args.max_size(); i < n; ++i) {
+      auto type = args.args_[i].type_;
+      if (type == internal::named_arg_type)
+        push_back(args.args_[i].value_);
+    }
+  }
 
-    struct hex_writer {
-      int_writer& self;
-      int num_digits;
+  // This template provides operations for formatting and writing data into a
+  // character range.
+  template <typename Range> class basic_writer
+  {
+  public:
+    using char_type    = typename Range::value_type;
+    using iterator     = typename Range::iterator;
+    using format_specs = basic_format_specs<char_type>;
+
+  private:
+    iterator             out_; // Output iterator.
+    internal::locale_ref locale_;
+
+    // Attempts to reserve space for n extra characters in the output range.
+    // Returns a pointer to the reserved range or a reference to out_.
+    auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n))
+    {
+      return internal::reserve(out_, n);
+    }
 
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_uint<4, char_type>(it, self.abs_value, num_digits,
-                                                 self.specs.type != 'x');
+    template <typename F> struct padded_int_writer
+    {
+      size_t      size_;
+      string_view prefix;
+      char_type   fill;
+      std::size_t padding;
+      F           f;
+
+      size_t size() const { return size_; }
+      size_t width() const { return size_; }
+
+      template <typename It> void operator()(It &&it) const
+      {
+        if (prefix.size() != 0)
+          it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
+        it = std::fill_n(it, padding, fill);
+        f(it);
       }
     };
 
-    void on_hex() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = specs.type;
+    // Writes an integer in the format
+    //   <left-padding><prefix><numeric-padding><digits><right-padding>
+    // where <digits> are written by f(it).
+    template <typename F>
+    void write_int(int num_digits, string_view prefix, format_specs specs, F f)
+    {
+      std::size_t size    = prefix.size() + internal::to_unsigned(num_digits);
+      char_type   fill    = specs.fill[0];
+      std::size_t padding = 0;
+      if (specs.align == align::numeric) {
+        auto unsiged_width = internal::to_unsigned(specs.width);
+        if (unsiged_width > size) {
+          padding = unsiged_width - size;
+          size    = unsiged_width;
+        }
       }
-      int num_digits = internal::count_digits<4>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       hex_writer{*this, num_digits});
+      else if (specs.precision > num_digits) {
+        size    = prefix.size() + internal::to_unsigned(specs.precision);
+        padding = internal::to_unsigned(specs.precision - num_digits);
+        fill    = static_cast<char_type>('0');
+      }
+      if (specs.align == align::none)
+        specs.align = align::right;
+      write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
     }
 
-    template <int BITS> struct bin_writer {
-      unsigned_type abs_value;
-      int num_digits;
+    // Writes a decimal integer.
+    template <typename Int> void write_decimal(Int value)
+    {
+      auto abs_value   = static_cast<uint32_or_64_or_128_t<Int>>(value);
+      bool is_negative = internal::is_negative(value);
+      // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
+      if (is_negative)
+        abs_value = ~abs_value + 1;
+      int    num_digits = internal::count_digits(abs_value);
+      auto &&it         = reserve((is_negative ? 1 : 0) + static_cast<size_t>(num_digits));
+      if (is_negative)
+        *it++ = static_cast<char_type>('-');
+      it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+    }
 
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_uint<BITS, char_type>(it, abs_value, num_digits);
+    // The handle_int_type_spec handler that writes an integer.
+    template <typename Int, typename Specs> struct int_writer
+    {
+      using unsigned_type = uint32_or_64_or_128_t<Int>;
+
+      basic_writer<Range> &writer;
+      const Specs &        specs;
+      unsigned_type        abs_value;
+      char                 prefix[4];
+      unsigned             prefix_size;
+
+      string_view get_prefix() const { return string_view(prefix, prefix_size); }
+
+      int_writer(basic_writer<Range> &w, Int value, const Specs &s)
+          : writer(w), specs(s), abs_value(static_cast<unsigned_type>(value)), prefix_size(0)
+      {
+        if (internal::is_negative(value)) {
+          prefix[0] = '-';
+          ++prefix_size;
+          abs_value = 0 - abs_value;
+        }
+        else if (specs.sign != sign::none && specs.sign != sign::minus) {
+          prefix[0] = specs.sign == sign::plus ? '+' : ' ';
+          ++prefix_size;
+        }
       }
-    };
 
-    void on_bin() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = static_cast<char>(specs.type);
+      struct dec_writer
+      {
+        unsigned_type abs_value;
+        int           num_digits;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+        }
+      };
+
+      void on_dec()
+      {
+        int num_digits = internal::count_digits(abs_value);
+        writer.write_int(num_digits, get_prefix(), specs, dec_writer{abs_value, num_digits});
       }
-      int num_digits = internal::count_digits<1>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<1>{abs_value, num_digits});
-    }
 
-    void on_oct() {
-      int num_digits = internal::count_digits<3>(abs_value);
-      if (specs.alt && specs.precision <= num_digits) {
-        // Octal prefix '0' is counted as a digit, so only add it if precision
-        // is not greater than the number of digits.
-        prefix[prefix_size++] = '0';
+      struct hex_writer
+      {
+        int_writer &self;
+        int         num_digits;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          it = internal::format_uint<4, char_type>(it, self.abs_value, num_digits,
+                                                   self.specs.type != 'x');
+        }
+      };
+
+      void on_hex()
+      {
+        if (specs.alt) {
+          prefix[prefix_size++] = '0';
+          prefix[prefix_size++] = specs.type;
+        }
+        int num_digits = internal::count_digits<4>(abs_value);
+        writer.write_int(num_digits, get_prefix(), specs, hex_writer{*this, num_digits});
       }
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<3>{abs_value, num_digits});
-    }
-
-    enum { sep_size = 1 };
-
-    struct num_writer {
-      unsigned_type abs_value;
-      int size;
-      char_type sep;
-
-      template <typename It> void operator()(It&& it) const {
-        basic_string_view<char_type> s(&sep, sep_size);
-        // Index of a decimal digit with the least significant digit having
-        // index 0.
-        unsigned digit_index = 0;
-        it = internal::format_decimal<char_type>(
-            it, abs_value, size, [s, &digit_index](char_type*& buffer) {
-              if (++digit_index % 3 != 0) return;
-              buffer -= s.size();
-              std::uninitialized_copy(s.data(), s.data() + s.size(),
-                                      internal::make_checked(buffer, s.size()));
-            });
+
+      template <int BITS> struct bin_writer
+      {
+        unsigned_type abs_value;
+        int           num_digits;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          it = internal::format_uint<BITS, char_type>(it, abs_value, num_digits);
+        }
+      };
+
+      void on_bin()
+      {
+        if (specs.alt) {
+          prefix[prefix_size++] = '0';
+          prefix[prefix_size++] = static_cast<char>(specs.type);
+        }
+        int num_digits = internal::count_digits<1>(abs_value);
+        writer.write_int(num_digits, get_prefix(), specs, bin_writer<1>{abs_value, num_digits});
       }
-    };
 
-    void on_num() {
-      char_type sep = internal::thousands_sep<char_type>(writer.locale_);
-      if (!sep) return on_dec();
-      int num_digits = internal::count_digits(abs_value);
-      int size = num_digits + sep_size * ((num_digits - 1) / 3);
-      writer.write_int(size, get_prefix(), specs,
-                       num_writer{abs_value, size, sep});
-    }
+      void on_oct()
+      {
+        int num_digits = internal::count_digits<3>(abs_value);
+        if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
+          // Octal prefix '0' is counted as a digit, so only add it if precision
+          // is not greater than the number of digits.
+          prefix[prefix_size++] = '0';
+        }
+        writer.write_int(num_digits, get_prefix(), specs, bin_writer<3>{abs_value, num_digits});
+      }
 
-    FMT_NORETURN void on_error() {
-      FMT_THROW(format_error("invalid type specifier"));
-    }
-  };
+      enum { sep_size = 1 };
+
+      struct num_writer
+      {
+        unsigned_type abs_value;
+        int           size;
+        char_type     sep;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          basic_string_view<char_type> s(&sep, sep_size);
+          // Index of a decimal digit with the least significant digit having
+          // index 0.
+          unsigned digit_index = 0;
+          it                   = internal::format_decimal<char_type>(
+              it, abs_value, size, [s, &digit_index](char_type *&buffer) {
+                if (++digit_index % 3 != 0)
+                  return;
+                buffer -= s.size();
+                std::uninitialized_copy(s.data(), s.data() + s.size(),
+                                        internal::make_checked(buffer, s.size()));
+              });
+        }
+      };
+
+      void on_num()
+      {
+        char_type sep = internal::thousands_sep<char_type>(writer.locale_);
+        if (!sep)
+          return on_dec();
+        int num_digits = internal::count_digits(abs_value);
+        int size       = num_digits + sep_size * ((num_digits - 1) / 3);
+        writer.write_int(size, get_prefix(), specs, num_writer{abs_value, size, sep});
+      }
 
-  enum { inf_size = 3 };  // This is an enum to workaround a bug in MSVC.
+      FMT_NORETURN void on_error() { FMT_THROW(format_error("invalid type specifier")); }
+    };
 
-  struct inf_or_nan_writer {
-    char sign;
-    bool as_percentage;
-    const char* str;
+    enum { inf_size = 3 }; // This is an enum to workaround a bug in MSVC.
 
-    size_t size() const {
-      return static_cast<std::size_t>(inf_size + (sign ? 1 : 0) +
-                                      (as_percentage ? 1 : 0));
-    }
-    size_t width() const { return size(); }
+    struct inf_or_nan_writer
+    {
+      sign_t      sign;
+      bool        as_percentage;
+      const char *str;
 
-    template <typename It> void operator()(It&& it) const {
-      if (sign) *it++ = static_cast<char_type>(sign);
-      it = internal::copy_str<char_type>(
-          str, str + static_cast<std::size_t>(inf_size), it);
-      if (as_percentage) *it++ = static_cast<char_type>('%');
-    }
-  };
+      size_t size() const
+      {
+        return static_cast<std::size_t>(inf_size + (sign ? 1 : 0) + (as_percentage ? 1 : 0));
+      }
+      size_t width() const { return size(); }
+
+      template <typename It> void operator()(It &&it) const
+      {
+        if (sign)
+          *it++ = static_cast<char_type>(data::signs[sign]);
+        it = internal::copy_str<char_type>(str, str + static_cast<std::size_t>(inf_size), it);
+        if (as_percentage)
+          *it++ = static_cast<char_type>('%');
+      }
+    };
 
-  struct double_writer {
-    char sign;
-    internal::buffer<char>& buffer;
-    char* decimal_point_pos;
-    char_type decimal_point;
+    struct double_writer
+    {
+      sign_t                  sign;
+      internal::buffer<char> &buffer;
+      char *                  decimal_point_pos;
+      char_type               decimal_point;
+
+      size_t size() const { return buffer.size() + (sign ? 1 : 0); }
+      size_t width() const { return size(); }
+
+      template <typename It> void operator()(It &&it)
+      {
+        if (sign)
+          *it++ = static_cast<char_type>(data::signs[sign]);
+        auto begin = buffer.begin();
+        if (decimal_point_pos) {
+          it    = internal::copy_str<char_type>(begin, decimal_point_pos, it);
+          *it++ = decimal_point;
+          begin = decimal_point_pos + 1;
+        }
+        it = internal::copy_str<char_type>(begin, buffer.end(), it);
+      }
+    };
 
-    size_t size() const { return buffer.size() + (sign ? 1 : 0); }
-    size_t width() const { return size(); }
+    template <typename Char> struct str_writer
+    {
+      const Char *s;
+      size_t      size_;
 
-    template <typename It> void operator()(It&& it) {
-      if (sign) *it++ = static_cast<char_type>(sign);
-      auto begin = buffer.begin();
-      if (decimal_point_pos) {
-        it = internal::copy_str<char_type>(begin, decimal_point_pos, it);
-        *it++ = decimal_point;
-        begin = decimal_point_pos + 1;
+      size_t size() const { return size_; }
+      size_t width() const
+      {
+        return internal::count_code_points(basic_string_view<Char>(s, size_));
       }
-      it = internal::copy_str<char_type>(begin, buffer.end(), it);
-    }
-  };
 
-  class grisu_writer {
-   private:
-    internal::buffer<char>& digits_;
-    size_t size_;
-    char sign_;
-    int exp_;
-    internal::gen_digits_params params_;
-    char_type decimal_point_;
-
-   public:
-    grisu_writer(char sign, internal::buffer<char>& digits, int exp,
-                 const internal::gen_digits_params& params,
-                 char_type decimal_point)
-        : digits_(digits),
-          sign_(sign),
-          exp_(exp),
-          params_(params),
-          decimal_point_(decimal_point) {
-      int num_digits = static_cast<int>(digits.size());
-      int full_exp = num_digits + exp - 1;
-      int precision = params.num_digits > 0 ? params.num_digits : 11;
-      params_.fixed |= full_exp >= -4 && full_exp < precision;
-      auto it = internal::grisu_prettify<char>(
-          digits.data(), num_digits, exp, internal::counting_iterator<char>(),
-          params_, '.');
-      size_ = it.count();
-    }
+      template <typename It> void operator()(It &&it) const
+      {
+        it = internal::copy_str<char_type>(s, s + size_, it);
+      }
+    };
 
-    size_t size() const { return size_ + (sign_ ? 1 : 0); }
-    size_t width() const { return size(); }
+    template <typename UIntPtr> struct pointer_writer
+    {
+      UIntPtr value;
+      int     num_digits;
 
-    template <typename It> void operator()(It&& it) {
-      if (sign_) *it++ = static_cast<char_type>(sign_);
-      int num_digits = static_cast<int>(digits_.size());
-      it = internal::grisu_prettify<char_type>(digits_.data(), num_digits, exp_,
-                                               it, params_, decimal_point_);
-    }
-  };
+      size_t size() const { return to_unsigned(num_digits) + 2; }
+      size_t width() const { return size(); }
 
-  template <typename Char> struct str_writer {
-    const Char* s;
-    size_t size_;
+      template <typename It> void operator()(It &&it) const
+      {
+        *it++ = static_cast<char_type>('0');
+        *it++ = static_cast<char_type>('x');
+        it    = internal::format_uint<4, char_type>(it, value, num_digits);
+      }
+    };
 
-    size_t size() const { return size_; }
-    size_t width() const {
-      return internal::count_code_points(basic_string_view<Char>(s, size_));
+  public:
+    /** Constructs a ``basic_writer`` object. */
+    explicit basic_writer(Range out, internal::locale_ref loc = internal::locale_ref())
+        : out_(out.begin()), locale_(loc)
+    {
     }
 
-    template <typename It> void operator()(It&& it) const {
-      it = internal::copy_str<char_type>(s, s + size_, it);
+    iterator out() const { return out_; }
+
+    // Writes a value in the format
+    //   <left-padding><value><right-padding>
+    // where <value> is written by f(it).
+    template <typename F> void write_padded(const format_specs &specs, F &&f)
+    {
+      // User-perceived width (in code points).
+      unsigned width           = to_unsigned(specs.width);
+      size_t   size            = f.size(); // The number of code units.
+      size_t   num_code_points = width != 0 ? f.width() : size;
+      if (width <= num_code_points)
+        return f(reserve(size));
+      auto &&     it      = reserve(width + (size - num_code_points));
+      char_type   fill    = specs.fill[0];
+      std::size_t padding = width - num_code_points;
+      if (specs.align == align::right) {
+        it = std::fill_n(it, padding, fill);
+        f(it);
+      }
+      else if (specs.align == align::center) {
+        std::size_t left_padding = padding / 2;
+        it                       = std::fill_n(it, left_padding, fill);
+        f(it);
+        it = std::fill_n(it, padding - left_padding, fill);
+      }
+      else {
+        f(it);
+        it = std::fill_n(it, padding, fill);
+      }
     }
-  };
-
-  template <typename UIntPtr> struct pointer_writer {
-    UIntPtr value;
-    int num_digits;
 
-    size_t size() const { return to_unsigned(num_digits) + 2; }
-    size_t width() const { return size(); }
-
-    template <typename It> void operator()(It&& it) const {
-      *it++ = static_cast<char_type>('0');
-      *it++ = static_cast<char_type>('x');
-      it = internal::format_uint<4, char_type>(it, value, num_digits);
-    }
-  };
+    void write(int value) { write_decimal(value); }
+    void write(long value) { write_decimal(value); }
+    void write(long long value) { write_decimal(value); }
 
- public:
-  /** Constructs a ``basic_writer`` object. */
-  explicit basic_writer(Range p_out,
-                        internal::locale_ref loc = internal::locale_ref())
-      : out_(p_out.begin()), locale_(loc) {}
-
-  iterator out() const { return out_; }
-
-  // Writes a value in the format
-  //   <left-padding><value><right-padding>
-  // where <value> is written by f(it).
-  template <typename F> void write_padded(const format_specs& specs, F&& f) {
-    // User-perceived width (in code points).
-    unsigned width = to_unsigned(specs.width);
-    size_t size = f.size();  // The number of code units.
-    size_t num_code_points = width != 0 ? f.width() : size;
-    if (width <= num_code_points) return f(reserve(size));
-    auto&& it = reserve(width + (size - num_code_points));
-    char_type fill = specs.fill[0];
-    std::size_t padding = width - num_code_points;
-    if (specs.align == align::right) {
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    } else if (specs.align == align::center) {
-      std::size_t left_padding = padding / 2;
-      it = std::fill_n(it, left_padding, fill);
-      f(it);
-      it = std::fill_n(it, padding - left_padding, fill);
-    } else {
-      f(it);
-      it = std::fill_n(it, padding, fill);
-    }
-  }
-
-  void write(int value) { write_decimal(value); }
-  void write(long value) { write_decimal(value); }
-  void write(long long value) { write_decimal(value); }
-
-  void write(unsigned value) { write_decimal(value); }
-  void write(unsigned long value) { write_decimal(value); }
-  void write(unsigned long long value) { write_decimal(value); }
-
-  // Writes a formatted integer.
-  template <typename T, typename Spec>
-  void write_int(T value, const Spec& spec) {
-    internal::handle_int_type_spec(spec.type,
-                                   int_writer<T, Spec>(*this, value, spec));
-  }
-
-  void write(double value, const format_specs& specs = format_specs()) {
-    write_double(value, specs);
-  }
+    void write(unsigned value) { write_decimal(value); }
+    void write(unsigned long value) { write_decimal(value); }
+    void write(unsigned long long value) { write_decimal(value); }
 
-  /**
-    \rst
-    Formats *value* using the general format for floating-point numbers
-    (``'g'``) and writes it to the buffer.
-    \endrst
-   */
-  void write(long double value, const format_specs& specs = format_specs()) {
-    write_double(value, specs);
-  }
+#if FMT_USE_INT128
+    void write(int128_t value) { write_decimal(value); }
+    void write(uint128_t value) { write_decimal(value); }
+#endif
 
-  // Formats a floating-point number (double or long double).
-  template <typename T, bool USE_GRISU = fmt::internal::use_grisu<T>()>
-  void write_double(T value, const format_specs& specs);
+    // Writes a formatted integer.
+    template <typename T, typename Spec> void write_int(T value, const Spec &spec)
+    {
+      internal::handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
+    }
 
-  /** Writes a character to the buffer. */
-  void write(char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
+    void write(float value, const format_specs &specs = format_specs()) { write_fp(value, specs); }
 
-  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
-  void write(Char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
+    void write(double value, const format_specs &specs = format_specs()) { write_fp(value, specs); }
 
-  /**
-    \rst
-    Writes *value* to the buffer.
-    \endrst
-   */
-  void write(string_view value) {
-    auto&& it = reserve(value.size());
-    it = internal::copy_str<char_type>(value.begin(), value.end(), it);
-  }
-  void write(wstring_view value) {
-    static_assert(std::is_same<char_type, wchar_t>::value, "");
-    auto&& it = reserve(value.size());
-    it = std::copy(value.begin(), value.end(), it);
-  }
+    /**
+      \rst
+      Formats *value* using the general format for floating-point numbers
+      (``'g'``) and writes it to the buffer.
+      \endrst
+     */
+    void write(long double value, const format_specs &specs = format_specs())
+    {
+      write_fp(value, specs);
+    }
 
-  // Writes a formatted string.
-  template <typename Char>
-  void write(const Char* s, std::size_t size, const format_specs& specs) {
-    write_padded(specs, str_writer<Char>{s, size});
-  }
+    // Formats a floating-point number (float, double, or long double).
+    template <typename T, bool USE_GRISU = fmt::internal::use_grisu<T>()>
+    void write_fp(T value, const format_specs &specs);
 
-  template <typename Char>
-  void write(basic_string_view<Char> s,
-             const format_specs& specs = format_specs()) {
-    const Char* data = s.data();
-    std::size_t size = s.size();
-    if (specs.precision >= 0 && internal::to_unsigned(specs.precision) < size)
-      size = internal::to_unsigned(specs.precision);
-    write(data, size, specs);
-  }
+    /** Writes a character to the buffer. */
+    void write(char value)
+    {
+      auto &&it = reserve(1);
+      *it++     = value;
+    }
 
-  template <typename UIntPtr>
-  void write_pointer(UIntPtr value, const format_specs* specs) {
-    int num_digits = internal::count_digits<4>(value);
-    auto pw = pointer_writer<UIntPtr>{value, num_digits};
-    if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
-    format_specs specs_copy = *specs;
-    if (specs_copy.align == align::none) specs_copy.align = align::right;
-    write_padded(specs_copy, pw);
-  }
-};
+    template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
+    void write(Char value)
+    {
+      auto &&it = reserve(1);
+      *it++     = value;
+    }
 
-using writer = basic_writer<buffer_range<char>>;
+    /**
+      \rst
+      Writes *value* to the buffer.
+      \endrst
+     */
+    void write(string_view value)
+    {
+      auto &&it = reserve(value.size());
+      it        = internal::copy_str<char_type>(value.begin(), value.end(), it);
+    }
+    void write(wstring_view value)
+    {
+      static_assert(std::is_same<char_type, wchar_t>::value, "");
+      auto &&it = reserve(value.size());
+      it        = std::copy(value.begin(), value.end(), it);
+    }
 
-template <typename Range, typename ErrorHandler = internal::error_handler>
-class arg_formatter_base {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
+    // Writes a formatted string.
+    template <typename Char> void write(const Char *s, std::size_t size, const format_specs &specs)
+    {
+      write_padded(specs, str_writer<Char>{s, size});
+    }
 
- private:
-  using writer_type = basic_writer<Range>;
-  writer_type writer_;
-  format_specs* specs_;
+    template <typename Char>
+    void write(basic_string_view<Char> s, const format_specs &specs = format_specs())
+    {
+      const Char *data = s.data();
+      std::size_t size = s.size();
+      if (specs.precision >= 0 && internal::to_unsigned(specs.precision) < size)
+        size = internal::to_unsigned(specs.precision);
+      write(data, size, specs);
+    }
 
-  struct char_writer {
-    char_type value;
+    template <typename UIntPtr> void write_pointer(UIntPtr value, const format_specs *specs)
+    {
+      int  num_digits = internal::count_digits<4>(value);
+      auto pw         = pointer_writer<UIntPtr>{value, num_digits};
+      if (!specs)
+        return pw(reserve(to_unsigned(num_digits) + 2));
+      format_specs specs_copy = *specs;
+      if (specs_copy.align == align::none)
+        specs_copy.align = align::right;
+      write_padded(specs_copy, pw);
+    }
+  };
 
-    size_t size() const { return 1; }
-    size_t width() const { return 1; }
+  using writer = basic_writer<buffer_range<char>>;
 
-    template <typename It> void operator()(It&& it) const { *it++ = value; }
+  template <typename T> struct is_integral : std::is_integral<T>
+  {
+  };
+  template <> struct is_integral<int128_t> : std::true_type
+  {
+  };
+  template <> struct is_integral<uint128_t> : std::true_type
+  {
   };
 
-  void write_char(char_type value) {
-    if (specs_)
-      writer_.write_padded(*specs_, char_writer{value});
-    else
-      writer_.write(value);
-  }
-
-  void write_pointer(const void* p) {
-    writer_.write_pointer(internal::bit_cast<internal::uintptr_t>(p), specs_);
-  }
+  template <typename Range, typename ErrorHandler = internal::error_handler>
+  class arg_formatter_base
+  {
+  public:
+    using char_type    = typename Range::value_type;
+    using iterator     = typename Range::iterator;
+    using format_specs = basic_format_specs<char_type>;
 
- protected:
-  writer_type& writer() { return writer_; }
-  FMT_DEPRECATED format_specs* spec() { return specs_; }
-  format_specs* specs() { return specs_; }
-  iterator out() { return writer_.out(); }
+  private:
+    using writer_type = basic_writer<Range>;
+    writer_type   writer_;
+    format_specs *specs_;
 
-  void write(bool value) {
-    string_view sv(value ? "true" : "false");
-    specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-  }
+    struct char_writer
+    {
+      char_type value;
 
-  void write(const char_type* value) {
-    if (!value) {
-      FMT_THROW(format_error("string pointer is null"));
-    } else {
-      auto length = std::char_traits<char_type>::length(value);
-      basic_string_view<char_type> sv(value, length);
-      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-    }
-  }
+      size_t size() const { return 1; }
+      size_t width() const { return 1; }
 
- public:
-  arg_formatter_base(Range r, format_specs* s, locale_ref loc)
-      : writer_(r, loc), specs_(s) {}
+      template <typename It> void operator()(It &&it) const { *it++ = value; }
+    };
 
-  iterator operator()(monostate) {
-    FMT_ASSERT(false, "invalid argument type");
-    return out();
-  }
+    void write_char(char_type value)
+    {
+      if (specs_)
+        writer_.write_padded(*specs_, char_writer{value});
+      else
+        writer_.write(value);
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  iterator operator()(T value) {
-    if (specs_)
-      writer_.write_int(value, *specs_);
-    else
-      writer_.write(value);
-    return out();
-  }
+    void write_pointer(const void *p)
+    {
+      writer_.write_pointer(internal::bit_cast<internal::uintptr_t>(p), specs_);
+    }
 
-  iterator operator()(char_type value) {
-    internal::handle_char_specs(
-        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
-    return out();
-  }
+  protected:
+    writer_type &  writer() { return writer_; }
+    FMT_DEPRECATED format_specs *spec() { return specs_; }
+    format_specs *               specs() { return specs_; }
+    iterator                     out() { return writer_.out(); }
 
-  iterator operator()(bool value) {
-    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
-    write(value != 0);
-    return out();
-  }
+    void write(bool value)
+    {
+      string_view sv(value ? "true" : "false");
+      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    writer_.write_double(value, specs_ ? *specs_ : format_specs());
-    return out();
-  }
+    void write(const char_type *value)
+    {
+      if (!value) {
+        FMT_THROW(format_error("string pointer is null"));
+      }
+      else {
+        auto                         length = std::char_traits<char_type>::length(value);
+        basic_string_view<char_type> sv(value, length);
+        specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+      }
+    }
 
-  struct char_spec_handler : ErrorHandler {
-    arg_formatter_base& formatter;
-    char_type value;
+  public:
+    arg_formatter_base(Range r, format_specs *s, locale_ref loc) : writer_(r, loc), specs_(s) {}
 
-    char_spec_handler(arg_formatter_base& f, char_type val)
-        : formatter(f), value(val) {}
+    iterator operator()(monostate)
+    {
+      FMT_ASSERT(false, "invalid argument type");
+      return out();
+    }
 
-    void on_int() {
-      if (formatter.specs_)
-        formatter.writer_.write_int(value, *formatter.specs_);
+    template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> iterator operator()(T value)
+    {
+      if (specs_)
+        writer_.write_int(value, *specs_);
       else
-        formatter.writer_.write(value);
+        writer_.write(value);
+      return out();
     }
-    void on_char() { formatter.write_char(value); }
-  };
-
-  struct cstring_spec_handler : internal::error_handler {
-    arg_formatter_base& formatter;
-    const char_type* value;
-
-    cstring_spec_handler(arg_formatter_base& f, const char_type* val)
-        : formatter(f), value(val) {}
 
-    void on_string() { formatter.write(value); }
-    void on_pointer() { formatter.write_pointer(value); }
-  };
-
-  iterator operator()(const char_type* value) {
-    if (!specs_) return write(value), out();
-    internal::handle_cstring_type_spec(specs_->type,
-                                       cstring_spec_handler(*this, value));
-    return out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    if (specs_) {
-      internal::check_string_type_spec(specs_->type, internal::error_handler());
-      writer_.write(value, *specs_);
-    } else {
-      writer_.write(value);
+    iterator operator()(char_type value)
+    {
+      internal::handle_char_specs(specs_, char_spec_handler(*this, static_cast<char_type>(value)));
+      return out();
     }
-    return out();
-  }
-
-  iterator operator()(const void* value) {
-    if (specs_)
-      check_pointer_type_spec(specs_->type, internal::error_handler());
-    write_pointer(value);
-    return out();
-  }
-};
 
-template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
+    iterator operator()(bool value)
+    {
+      if (specs_ && specs_->type)
+        return (*this)(value ? 1 : 0);
+      write(value != 0);
+      return out();
+    }
 
-// Parses the range [begin, end) as an unsigned integer. This function assumes
-// that the range is non-empty and the first character is a digit.
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
-                                        ErrorHandler&& eh) {
-  assert(begin != end && '0' <= *begin && *begin <= '9');
-  if (*begin == '0') {
-    ++begin;
-    return 0;
-  }
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  constexpr unsigned max_int = (std::numeric_limits<int>::max)();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
+    template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+    iterator operator()(T value)
+    {
+      writer_.write_fp(value, specs_ ? *specs_ : format_specs());
+      return out();
     }
-    value = value * 10 + unsigned(*begin - '0');
-    ++begin;
-  } while (begin != end && '0' <= *begin && *begin <= '9');
-  if (value > max_int) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
 
-template <typename Context> class custom_formatter {
- private:
-  using char_type = typename Context::char_type;
+    struct char_spec_handler : ErrorHandler
+    {
+      arg_formatter_base &formatter;
+      char_type           value;
 
-  basic_parse_context<char_type>& parse_ctx_;
-  Context& ctx_;
+      char_spec_handler(arg_formatter_base &f, char_type val) : formatter(f), value(val) {}
 
- public:
-  explicit custom_formatter(basic_parse_context<char_type>& parse_ctx,
-                            Context& ctx)
-      : parse_ctx_(parse_ctx), ctx_(ctx) {}
+      void on_int()
+      {
+        if (formatter.specs_)
+          formatter.writer_.write_int(value, *formatter.specs_);
+        else
+          formatter.writer_.write(value);
+      }
+      void on_char() { formatter.write_char(value); }
+    };
 
-  bool operator()(typename basic_format_arg<Context>::handle h) const {
-    h.format(parse_ctx_, ctx_);
-    return true;
-  }
+    struct cstring_spec_handler : internal::error_handler
+    {
+      arg_formatter_base &formatter;
+      const char_type *   value;
 
-  template <typename T> bool operator()(T) const { return false; }
-};
+      cstring_spec_handler(arg_formatter_base &f, const char_type *val) : formatter(f), value(val)
+      {
+      }
 
-template <typename T>
-using is_integer =
-    bool_constant<std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-                  !std::is_same<T, char>::value &&
-                  !std::is_same<T, wchar_t>::value>;
+      void on_string() { formatter.write(value); }
+      void on_pointer() { formatter.write_pointer(value); }
+    };
+
+    iterator operator()(const char_type *value)
+    {
+      if (!specs_)
+        return write(value), out();
+      internal::handle_cstring_type_spec(specs_->type, cstring_spec_handler(*this, value));
+      return out();
+    }
 
-template <typename ErrorHandler> class width_checker {
- public:
-  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
+    iterator operator()(basic_string_view<char_type> value)
+    {
+      if (specs_) {
+        internal::check_string_type_spec(specs_->type, internal::error_handler());
+        writer_.write(value, *specs_);
+      }
+      else {
+        writer_.write(value);
+      }
+      return out();
+    }
 
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative width");
-    return static_cast<unsigned long long>(value);
-  }
+    iterator operator()(const void *value)
+    {
+      if (specs_)
+        check_pointer_type_spec(specs_->type, internal::error_handler());
+      write_pointer(value);
+      return out();
+    }
+  };
 
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("width is not integer");
-    return 0;
+  template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c)
+  {
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
   }
 
- private:
-  ErrorHandler& handler_;
-};
+  // Parses the range [begin, end) as an unsigned integer. This function assumes
+  // that the range is non-empty and the first character is a digit.
+  template <typename Char, typename ErrorHandler>
+  FMT_CONSTEXPR int parse_nonnegative_int(const Char *&begin, const Char *end, ErrorHandler &&eh)
+  {
+    assert(begin != end && '0' <= *begin && *begin <= '9');
+    if (*begin == '0') {
+      ++begin;
+      return 0;
+    }
+    unsigned value = 0;
+    // Convert to unsigned to prevent a warning.
+    constexpr unsigned max_int = max_value<int>();
+    unsigned           big     = max_int / 10;
+    do {
+      // Check for overflow.
+      if (value > big) {
+        value = max_int + 1;
+        break;
+      }
+      value = value * 10 + unsigned(*begin - '0');
+      ++begin;
+    } while (begin != end && '0' <= *begin && *begin <= '9');
+    if (value > max_int)
+      eh.on_error("number is too big");
+    return static_cast<int>(value);
+  }
+
+  template <typename Context> class custom_formatter
+  {
+  private:
+    using char_type = typename Context::char_type;
+
+    basic_parse_context<char_type> &parse_ctx_;
+    Context &                       ctx_;
+
+  public:
+    explicit custom_formatter(basic_parse_context<char_type> &parse_ctx, Context &ctx)
+        : parse_ctx_(parse_ctx), ctx_(ctx)
+    {
+    }
 
-template <typename ErrorHandler> class precision_checker {
- public:
-  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
+    bool operator()(typename basic_format_arg<Context>::handle h) const
+    {
+      h.format(parse_ctx_, ctx_);
+      return true;
+    }
 
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative precision");
-    return static_cast<unsigned long long>(value);
-  }
+    template <typename T> bool operator()(T) const { return false; }
+  };
 
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("precision is not integer");
-    return 0;
-  }
+  template <typename T>
+  using is_integer =
+      bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
+                    !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value>;
+
+  template <typename ErrorHandler> class width_checker
+  {
+  public:
+    explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) : handler_(eh) {}
+
+    template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T value)
+    {
+      if (is_negative(value))
+        handler_.on_error("negative width");
+      return static_cast<unsigned long long>(value);
+    }
 
- private:
-  ErrorHandler& handler_;
-};
+    template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T)
+    {
+      handler_.on_error("width is not integer");
+      return 0;
+    }
 
-// A format specifier handler that sets fields in basic_format_specs.
-template <typename Char> class specs_setter {
- public:
-  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
-      : specs_(specs) {}
+  private:
+    ErrorHandler &handler_;
+  };
 
-  FMT_CONSTEXPR specs_setter(const specs_setter& other)
-      : specs_(other.specs_) {}
+  template <typename ErrorHandler> class precision_checker
+  {
+  public:
+    explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) : handler_(eh) {}
+
+    template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T value)
+    {
+      if (is_negative(value))
+        handler_.on_error("negative precision");
+      return static_cast<unsigned long long>(value);
+    }
 
-  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
-  FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; }
-  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
-  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
-  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
-  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
+    template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T)
+    {
+      handler_.on_error("precision is not integer");
+      return 0;
+    }
 
-  FMT_CONSTEXPR void on_zero() {
-    specs_.align = align::numeric;
-    specs_.fill[0] = Char('0');
-  }
+  private:
+    ErrorHandler &handler_;
+  };
 
-  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
-  FMT_CONSTEXPR void on_precision(int precision) {
-    specs_.precision = precision;
-  }
-  FMT_CONSTEXPR void end_precision() {}
+  // A format specifier handler that sets fields in basic_format_specs.
+  template <typename Char> class specs_setter
+  {
+  public:
+    explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs) : specs_(specs) {}
+
+    FMT_CONSTEXPR specs_setter(const specs_setter &other) : specs_(other.specs_) {}
+
+    FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
+    FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; }
+    FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
+    FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
+    FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
+    FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
+
+    FMT_CONSTEXPR void on_zero()
+    {
+      specs_.align   = align::numeric;
+      specs_.fill[0] = Char('0');
+    }
 
-  FMT_CONSTEXPR void on_type(Char type) {
-    specs_.type = static_cast<char>(type);
-  }
+    FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
+    FMT_CONSTEXPR void on_precision(int precision) { specs_.precision = precision; }
+    FMT_CONSTEXPR void end_precision() {}
 
- protected:
-  basic_format_specs<Char>& specs_;
-};
+    FMT_CONSTEXPR void on_type(Char type) { specs_.type = static_cast<char>(type); }
 
-template <typename ErrorHandler> class numeric_specs_checker {
- public:
-  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
-      : error_handler_(eh), arg_type_(arg_type) {}
+  protected:
+    basic_format_specs<Char> &specs_;
+  };
 
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic(arg_type_))
-      error_handler_.on_error("format specifier requires numeric argument");
-  }
+  template <typename ErrorHandler> class numeric_specs_checker
+  {
+  public:
+    FMT_CONSTEXPR numeric_specs_checker(ErrorHandler &eh, internal::type arg_type)
+        : error_handler_(eh), arg_type_(arg_type)
+    {
+    }
 
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
-      error_handler_.on_error("format specifier requires signed argument");
+    FMT_CONSTEXPR void require_numeric_argument()
+    {
+      if (!is_arithmetic_type(arg_type_))
+        error_handler_.on_error("format specifier requires numeric argument");
     }
-  }
 
-  FMT_CONSTEXPR void check_precision() {
-    if (is_integral(arg_type_) || arg_type_ == internal::pointer_type)
-      error_handler_.on_error("precision not allowed for this argument type");
-  }
+    FMT_CONSTEXPR void check_sign()
+    {
+      require_numeric_argument();
+      if (is_integral_type(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type &&
+          arg_type_ != internal::char_type) {
+        error_handler_.on_error("format specifier requires signed argument");
+      }
+    }
 
- private:
-  ErrorHandler& error_handler_;
-  internal::type arg_type_;
-};
+    FMT_CONSTEXPR void check_precision()
+    {
+      if (is_integral_type(arg_type_) || arg_type_ == internal::pointer_type)
+        error_handler_.on_error("precision not allowed for this argument type");
+    }
 
-// A format specifier handler that checks if specifiers are consistent with the
-// argument type.
-template <typename Handler> class specs_checker : public Handler {
- public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
-      : Handler(handler), checker_(*this, arg_type) {}
+  private:
+    ErrorHandler & error_handler_;
+    internal::type arg_type_;
+  };
 
-  FMT_CONSTEXPR specs_checker(const specs_checker& other)
-      : Handler(other), checker_(*this, other.arg_type_) {}
+  // A format specifier handler that checks if specifiers are consistent with the
+  // argument type.
+  template <typename Handler> class specs_checker : public Handler
+  {
+  public:
+    FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type)
+        : Handler(handler), checker_(*this, arg_type)
+    {
+    }
 
-  FMT_CONSTEXPR void on_align(align_t align) {
-    if (align == align::numeric) checker_.require_numeric_argument();
-    Handler::on_align(align);
-  }
+    FMT_CONSTEXPR specs_checker(const specs_checker &other)
+        : Handler(other), checker_(*this, other.arg_type_)
+    {
+    }
 
-  FMT_CONSTEXPR void on_plus() {
-    checker_.check_sign();
-    Handler::on_plus();
-  }
+    FMT_CONSTEXPR void on_align(align_t align)
+    {
+      if (align == align::numeric)
+        checker_.require_numeric_argument();
+      Handler::on_align(align);
+    }
 
-  FMT_CONSTEXPR void on_minus() {
-    checker_.check_sign();
-    Handler::on_minus();
-  }
+    FMT_CONSTEXPR void on_plus()
+    {
+      checker_.check_sign();
+      Handler::on_plus();
+    }
 
-  FMT_CONSTEXPR void on_space() {
-    checker_.check_sign();
-    Handler::on_space();
-  }
+    FMT_CONSTEXPR void on_minus()
+    {
+      checker_.check_sign();
+      Handler::on_minus();
+    }
 
-  FMT_CONSTEXPR void on_hash() {
-    checker_.require_numeric_argument();
-    Handler::on_hash();
-  }
+    FMT_CONSTEXPR void on_space()
+    {
+      checker_.check_sign();
+      Handler::on_space();
+    }
 
-  FMT_CONSTEXPR void on_zero() {
-    checker_.require_numeric_argument();
-    Handler::on_zero();
-  }
+    FMT_CONSTEXPR void on_hash()
+    {
+      checker_.require_numeric_argument();
+      Handler::on_hash();
+    }
 
-  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
+    FMT_CONSTEXPR void on_zero()
+    {
+      checker_.require_numeric_argument();
+      Handler::on_zero();
+    }
 
- private:
-  numeric_specs_checker<Handler> checker_;
-};
+    FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
 
-template <template <typename> class Handler, typename T, typename FormatArg,
-          typename ErrorHandler>
-FMT_CONSTEXPR void set_dynamic_spec(T& value, FormatArg arg, ErrorHandler eh) {
-  unsigned long long big_value =
-      visit_format_arg(Handler<ErrorHandler>(eh), arg);
-  if (big_value > to_unsigned((std::numeric_limits<int>::max)()))
-    eh.on_error("number is too big");
-  value = static_cast<T>(big_value);
-}
+  private:
+    numeric_specs_checker<Handler> checker_;
+  };
 
-struct auto_id {};
+  template <template <typename> class Handler, typename FormatArg, typename ErrorHandler>
+  FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh)
+  {
+    unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
+    if (value > to_unsigned(max_value<int>()))
+      eh.on_error("number is too big");
+    return static_cast<int>(value);
+  }
 
-template <typename Context>
-FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
-  auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("argument index out of range");
-  return arg;
-}
+  struct auto_id
+  {
+  };
 
-// The standard format specifier handler with checking.
-template <typename ParseContext, typename Context>
-class specs_handler : public specs_setter<typename Context::char_type> {
- public:
-  using char_type = typename Context::char_type;
+  template <typename Context>
+  FMT_CONSTEXPR typename Context::format_arg get_arg(Context &ctx, int id)
+  {
+    auto arg = ctx.arg(id);
+    if (!arg)
+      ctx.on_error("argument index out of range");
+    return arg;
+  }
+
+  // The standard format specifier handler with checking.
+  template <typename ParseContext, typename Context>
+  class specs_handler : public specs_setter<typename Context::char_type>
+  {
+  public:
+    using char_type = typename Context::char_type;
+
+    FMT_CONSTEXPR specs_handler(basic_format_specs<char_type> &specs, ParseContext &parse_ctx,
+                                Context &ctx)
+        : specs_setter<char_type>(specs), parse_context_(parse_ctx), context_(ctx)
+    {
+    }
 
-  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
-                              ParseContext& parse_ctx, Context& ctx)
-      : specs_setter<char_type>(specs),
-        parse_context_(parse_ctx),
-        context_(ctx) {}
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+      this->specs_.width =
+          get_dynamic_spec<width_checker>(get_arg(arg_id), context_.error_handler());
+    }
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    set_dynamic_spec<width_checker>(this->specs_.width, get_arg(arg_id),
-                                    context_.error_handler());
-  }
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+      this->specs_.precision =
+          get_dynamic_spec<precision_checker>(get_arg(arg_id), context_.error_handler());
+    }
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    set_dynamic_spec<precision_checker>(this->specs_.precision, get_arg(arg_id),
-                                        context_.error_handler());
-  }
+    void on_error(const char *message) { context_.on_error(message); }
 
-  void on_error(const char* message) { context_.on_error(message); }
+  private:
+    // This is only needed for compatibility with gcc 4.4.
+    using format_arg = typename Context::format_arg;
 
- private:
-  // This is only needed for compatibility with gcc 4.4.
-  using format_arg = typename Context::format_arg;
+    FMT_CONSTEXPR format_arg get_arg(auto_id)
+    {
+      return internal::get_arg(context_, parse_context_.next_arg_id());
+    }
 
-  FMT_CONSTEXPR format_arg get_arg(auto_id) {
-    return internal::get_arg(context_, parse_context_.next_arg_id());
-  }
+    FMT_CONSTEXPR format_arg get_arg(int arg_id)
+    {
+      parse_context_.check_arg_id(arg_id);
+      return internal::get_arg(context_, arg_id);
+    }
 
-  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return internal::get_arg(context_, arg_id);
-  }
+    FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id)
+    {
+      parse_context_.check_arg_id(arg_id);
+      return context_.arg(arg_id);
+    }
 
-  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return context_.arg(arg_id);
-  }
+    ParseContext &parse_context_;
+    Context &     context_;
+  };
 
-  ParseContext& parse_context_;
-  Context& context_;
-};
+  enum class arg_id_kind { none, index, name };
 
-struct string_view_metadata {
-  FMT_CONSTEXPR string_view_metadata() : offset_(0u), size_(0u) {}
-  template <typename Char>
-  FMT_CONSTEXPR string_view_metadata(basic_string_view<Char> primary_string,
-                                     basic_string_view<Char> view)
-      : offset_(to_unsigned(view.data() - primary_string.data())),
-        size_(view.size()) {}
-  FMT_CONSTEXPR string_view_metadata(std::size_t offset, std::size_t size)
-      : offset_(offset), size_(size) {}
-  template <typename Char>
-  FMT_CONSTEXPR basic_string_view<Char> to_view(const Char* str) const {
-    return {str + offset_, size_};
-  }
-
-  std::size_t offset_;
-  std::size_t size_;
-};
+  // An argument reference.
+  template <typename Char> struct arg_ref
+  {
+    FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
+    FMT_CONSTEXPR explicit arg_ref(int index) : kind(arg_id_kind::index), val(index) {}
+    FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+        : kind(arg_id_kind::name), val(name)
+    {
+    }
 
-enum class arg_id_kind { none, index, name };
+    FMT_CONSTEXPR arg_ref &operator=(int idx)
+    {
+      kind      = arg_id_kind::index;
+      val.index = idx;
+      return *this;
+    }
 
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-  FMT_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMT_CONSTEXPR explicit arg_ref(string_view_metadata name)
-      : kind(arg_id_kind::name), val(name) {}
+    arg_id_kind kind;
+    union value {
+      FMT_CONSTEXPR value() : index(0u) {}
+      FMT_CONSTEXPR value(int id) : index(id) {}
+      FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
 
-  FMT_CONSTEXPR arg_ref& operator=(int idx) {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
+      int                     index;
+      basic_string_view<Char> name;
+    } val;
+  };
 
-  arg_id_kind kind;
-  union value {
-    FMT_CONSTEXPR value() : index(0u) {}
-    FMT_CONSTEXPR value(int id) : index(id) {}
-    FMT_CONSTEXPR value(string_view_metadata n) : name(n) {}
+  // Format specifiers with width and precision resolved at formatting rather
+  // than parsing time to allow re-using the same parsed specifiers with
+  // different sets of arguments (precompilation of format strings).
+  template <typename Char> struct dynamic_format_specs : basic_format_specs<Char>
+  {
+    arg_ref<Char> width_ref;
+    arg_ref<Char> precision_ref;
+  };
 
-    int index;
-    string_view_metadata name;
-  } val;
-};
+  // Format spec handler that saves references to arguments representing dynamic
+  // width and precision to be resolved at formatting time.
+  template <typename ParseContext>
+  class dynamic_specs_handler : public specs_setter<typename ParseContext::char_type>
+  {
+  public:
+    using char_type = typename ParseContext::char_type;
+
+    FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type> &specs, ParseContext &ctx)
+        : specs_setter<char_type>(specs), specs_(specs), context_(ctx)
+    {
+    }
 
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow re-using the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char>
-struct dynamic_format_specs : basic_format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
+    FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
+        : specs_setter<char_type>(other), specs_(other.specs_), context_(other.context_)
+    {
+    }
 
-// Format spec handler that saves references to arguments representing dynamic
-// width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler
-    : public specs_setter<typename ParseContext::char_type> {
- public:
-  using char_type = typename ParseContext::char_type;
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+      specs_.width_ref = make_arg_ref(arg_id);
+    }
 
-  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
-                                      ParseContext& ctx)
-      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+      specs_.precision_ref = make_arg_ref(arg_id);
+    }
 
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
-      : specs_setter<char_type>(other),
-        specs_(other.specs_),
-        context_(other.context_) {}
+    FMT_CONSTEXPR void on_error(const char *message) { context_.on_error(message); }
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    specs_.width_ref = make_arg_ref(arg_id);
-  }
+  private:
+    using arg_ref_type = arg_ref<char_type>;
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    specs_.precision_ref = make_arg_ref(arg_id);
-  }
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id)
+    {
+      context_.check_arg_id(arg_id);
+      return arg_ref_type(arg_id);
+    }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id)
+    {
+      return arg_ref_type(context_.next_arg_id());
+    }
 
- private:
-  using arg_ref_type = arg_ref<char_type>;
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id)
+    {
+      context_.check_arg_id(arg_id);
+      basic_string_view<char_type> format_str(context_.begin(),
+                                              to_unsigned(context_.end() - context_.begin()));
+      return arg_ref_type(arg_id);
+    }
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
-  }
+    dynamic_format_specs<char_type> &specs_;
+    ParseContext &                   context_;
+  };
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
-    return arg_ref_type(context_.next_arg_id());
+  template <typename Char, typename IDHandler>
+  FMT_CONSTEXPR const Char *parse_arg_id(const Char *begin, const Char *end, IDHandler &&handler)
+  {
+    assert(begin != end);
+    Char c = *begin;
+    if (c == '}' || c == ':')
+      return handler(), begin;
+    if (c >= '0' && c <= '9') {
+      int index = parse_nonnegative_int(begin, end, handler);
+      if (begin == end || (*begin != '}' && *begin != ':'))
+        return handler.on_error("invalid format string"), begin;
+      handler(index);
+      return begin;
+    }
+    if (!is_name_start(c))
+      return handler.on_error("invalid format string"), begin;
+    auto it = begin;
+    do {
+      ++it;
+    } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
+    handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
+    return it;
   }
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
-    context_.check_arg_id(arg_id);
-    basic_string_view<char_type> format_str(
-        context_.begin(), to_unsigned(context_.end() - context_.begin()));
-    const auto id_metadata = string_view_metadata(format_str, arg_id);
-    return arg_ref_type(id_metadata);
-  }
+  // Adapts SpecHandler to IDHandler API for dynamic width.
+  template <typename SpecHandler, typename Char> struct width_adapter
+  {
+    explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) : handler(h) {}
 
-  dynamic_format_specs<char_type>& specs_;
-  ParseContext& context_;
-};
+    FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) { handler.on_dynamic_width(id); }
 
-template <typename Char, typename IDHandler>
-FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
-                                       IDHandler&& handler) {
-  assert(begin != end);
-  Char c = *begin;
-  if (c == '}' || c == ':') return handler(), begin;
-  if (c >= '0' && c <= '9') {
-    int index = parse_nonnegative_int(begin, end, handler);
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      return handler.on_error("invalid format string"), begin;
-    handler(index);
-    return begin;
-  }
-  if (!is_name_start(c))
-    return handler.on_error("invalid format string"), begin;
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
-  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
-  return it;
-}
+    FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
 
-// Adapts SpecHandler to IDHandler API for dynamic width.
-template <typename SpecHandler, typename Char> struct width_adapter {
-  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
+    SpecHandler &handler;
+  };
 
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_width(id);
-  }
+  // Adapts SpecHandler to IDHandler API for dynamic precision.
+  template <typename SpecHandler, typename Char> struct precision_adapter
+  {
+    explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) : handler(h) {}
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
+    FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) { handler.on_dynamic_precision(id); }
 
-  SpecHandler& handler;
-};
+    FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
 
-// Adapts SpecHandler to IDHandler API for dynamic precision.
-template <typename SpecHandler, typename Char> struct precision_adapter {
-  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
+    SpecHandler &handler;
+  };
 
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_precision(id);
+  // Parses fill and alignment.
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_align(const Char *begin, const Char *end, Handler &&handler)
+  {
+    FMT_ASSERT(begin != end, "");
+    auto align = align::none;
+    int  i     = 0;
+    if (begin + 1 != end)
+      ++i;
+    do {
+      switch (static_cast<char>(begin[i])) {
+      case '<': align = align::left; break;
+      case '>': align = align::right; break;
+#if FMT_NUMERIC_ALIGN
+      case '=': align = align::numeric; break;
+#endif
+      case '^': align = align::center; break;
+      }
+      if (align != align::none) {
+        if (i > 0) {
+          auto c = *begin;
+          if (c == '{')
+            return handler.on_error("invalid fill character '{'"), begin;
+          begin += 2;
+          handler.on_fill(c);
+        }
+        else
+          ++begin;
+        handler.on_align(align);
+        break;
+      }
+    } while (i-- > 0);
+    return begin;
   }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_width(const Char *begin, const Char *end, Handler &&handler)
+  {
+    FMT_ASSERT(begin != end, "");
+    if ('0' <= *begin && *begin <= '9') {
+      handler.on_width(parse_nonnegative_int(begin, end, handler));
+    }
+    else if (*begin == '{') {
+      ++begin;
+      if (begin != end)
+        begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
+      if (begin == end || *begin != '}')
+        return handler.on_error("invalid format string"), begin;
+      ++begin;
+    }
+    return begin;
   }
 
-  SpecHandler& handler;
-};
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_precision(const Char *begin, const Char *end, Handler &&handler)
+  {
+    ++begin;
+    auto c = begin != end ? *begin : Char();
+    if ('0' <= c && c <= '9') {
+      handler.on_precision(parse_nonnegative_int(begin, end, handler));
+    }
+    else if (c == '{') {
+      ++begin;
+      if (begin != end) {
+        begin = parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
+      }
+      if (begin == end || *begin++ != '}')
+        return handler.on_error("invalid format string"), begin;
+    }
+    else {
+      return handler.on_error("missing precision specifier"), begin;
+    }
+    handler.end_precision();
+    return begin;
+  }
 
-// Parses fill and alignment.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  auto align = align::none;
-  int i = 0;
-  if (begin + 1 != end) ++i;
-  do {
-    switch (static_cast<char>(begin[i])) {
-    case '<':
-      align = align::left;
-      break;
-    case '>':
-      align = align::right;
+  // Parses standard format specifiers and sends notifications about parsed
+  // components to handler.
+  template <typename Char, typename SpecHandler>
+  FMT_CONSTEXPR const Char *parse_format_specs(const Char *begin, const Char *end,
+                                               SpecHandler &&handler)
+  {
+    if (begin == end || *begin == '}')
+      return begin;
+
+    begin = parse_align(begin, end, handler);
+    if (begin == end)
+      return begin;
+
+    // Parse sign.
+    switch (static_cast<char>(*begin)) {
+    case '+':
+      handler.on_plus();
+      ++begin;
       break;
-    case '=':
-      align = align::numeric;
+    case '-':
+      handler.on_minus();
+      ++begin;
       break;
-    case '^':
-      align = align::center;
+    case ' ':
+      handler.on_space();
+      ++begin;
       break;
     }
-    if (align != align::none) {
-      if (i > 0) {
-        auto c = *begin;
-        if (c == '{')
-          return handler.on_error("invalid fill character '{'"), begin;
-        begin += 2;
-        handler.on_fill(c);
-      } else
-        ++begin;
-      handler.on_align(align);
-      break;
-    }
-  } while (i-- > 0);
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    handler.on_width(parse_nonnegative_int(begin, end, handler));
-  } else if (*begin == '{') {
-    ++begin;
-    if (begin != end)
-      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
-    if (begin == end || *begin != '}')
-      return handler.on_error("invalid format string"), begin;
-    ++begin;
-  }
-  return begin;
-}
+    if (begin == end)
+      return begin;
 
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
-                                          Handler&& handler) {
-  ++begin;
-  auto c = begin != end ? *begin : Char();
-  if ('0' <= c && c <= '9') {
-    handler.on_precision(parse_nonnegative_int(begin, end, handler));
-  } else if (c == '{') {
-    ++begin;
-    if (begin != end) {
-      begin =
-          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
+    if (*begin == '#') {
+      handler.on_hash();
+      if (++begin == end)
+        return begin;
     }
-    if (begin == end || *begin++ != '}')
-      return handler.on_error("invalid format string"), begin;
-  } else {
-    return handler.on_error("missing precision specifier"), begin;
-  }
-  handler.end_precision();
-  return begin;
-}
 
-// Parses standard format specifiers and sends notifications about parsed
-// components to handler.
-template <typename Char, typename SpecHandler>
-FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
-                                             SpecHandler&& handler) {
-  if (begin == end || *begin == '}') return begin;
-
-  begin = parse_align(begin, end, handler);
-  if (begin == end) return begin;
+    // Parse zero flag.
+    if (*begin == '0') {
+      handler.on_zero();
+      if (++begin == end)
+        return begin;
+    }
 
-  // Parse sign.
-  switch (static_cast<char>(*begin)) {
-  case '+':
-    handler.on_plus();
-    ++begin;
-    break;
-  case '-':
-    handler.on_minus();
-    ++begin;
-    break;
-  case ' ':
-    handler.on_space();
-    ++begin;
-    break;
-  }
-  if (begin == end) return begin;
+    begin = parse_width(begin, end, handler);
+    if (begin == end)
+      return begin;
 
-  if (*begin == '#') {
-    handler.on_hash();
-    if (++begin == end) return begin;
-  }
+    // Parse precision.
+    if (*begin == '.') {
+      begin = parse_precision(begin, end, handler);
+    }
 
-  // Parse zero flag.
-  if (*begin == '0') {
-    handler.on_zero();
-    if (++begin == end) return begin;
+    // Parse type.
+    if (begin != end && *begin != '}')
+      handler.on_type(*begin++);
+    return begin;
   }
 
-  begin = parse_width(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse precision.
-  if (*begin == '.') {
-    begin = parse_precision(begin, end, handler);
+  // Return the result via the out param to workaround gcc bug 77539.
+  template <bool IS_CONSTEXPR, typename T, typename Ptr = const T *>
+  FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
+  {
+    for (out = first; out != last; ++out) {
+      if (*out == value)
+        return true;
+    }
+    return false;
   }
 
-  // Parse type.
-  if (begin != end && *begin != '}') handler.on_type(*begin++);
-  return begin;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
+  template <>
+  inline bool find<false, char>(const char *first, const char *last, char value, const char *&out)
+  {
+    out = static_cast<const char *>(std::memchr(first, value, internal::to_unsigned(last - first)));
+    return out != nullptr;
   }
-  return false;
-}
 
-template <>
-inline bool find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) {
-  out = static_cast<const char*>(
-      std::memchr(first, value, internal::to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-template <typename Handler, typename Char> struct id_adapter {
-  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_arg_id(id);
-  }
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-  Handler& handler;
-};
+  template <typename Handler, typename Char> struct id_adapter
+  {
+    FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) { handler.on_arg_id(id); }
+    FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
+    Handler &          handler;
+  };
 
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
-                                       Handler&& handler) {
-  struct pfs_writer {
-    FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
-      if (begin == end) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(begin, end, '}', p))
-          return handler_.on_text(begin, end);
-        ++p;
-        if (p == end || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(begin, p);
-        begin = p + 1;
+  template <bool IS_CONSTEXPR, typename Char, typename Handler>
+  FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str, Handler &&handler)
+  {
+    struct pfs_writer
+    {
+      FMT_CONSTEXPR void operator()(const Char *begin, const Char *end)
+      {
+        if (begin == end)
+          return;
+        for (;;) {
+          const Char *p = nullptr;
+          if (!find<IS_CONSTEXPR>(begin, end, '}', p))
+            return handler_.on_text(begin, end);
+          ++p;
+          if (p == end || *p != '}')
+            return handler_.on_error("unmatched '}' in format string");
+          handler_.on_text(begin, p);
+          begin = p + 1;
+        }
       }
-    }
-    Handler& handler_;
-  } write{handler};
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
-      return write(begin, end);
-    write(begin, p);
-    ++p;
-    if (p == end) return handler.on_error("invalid format string");
-    if (static_cast<char>(*p) == '}') {
-      handler.on_arg_id();
-      handler.on_replacement_field(p);
-    } else if (*p == '{') {
-      handler.on_text(p, p + 1);
-    } else {
-      p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
-      Char c = p != end ? *p : Char();
-      if (c == '}') {
+      Handler &handler_;
+    } write{handler};
+    auto begin = format_str.data();
+    auto end   = begin + format_str.size();
+    while (begin != end) {
+      // Doing two passes with memchr (one for '{' and another for '}') is up to
+      // 2.5x faster than the naive one-pass implementation on big format strings.
+      const Char *p = begin;
+      if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
+        return write(begin, end);
+      write(begin, p);
+      ++p;
+      if (p == end)
+        return handler.on_error("invalid format string");
+      if (static_cast<char>(*p) == '}') {
+        handler.on_arg_id();
         handler.on_replacement_field(p);
-      } else if (c == ':') {
-        p = handler.on_format_specs(p + 1, end);
-        if (p == end || *p != '}')
-          return handler.on_error("unknown format specifier");
-      } else {
-        return handler.on_error("missing '}' in format string");
       }
+      else if (*p == '{') {
+        handler.on_text(p, p + 1);
+      }
+      else {
+        p      = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
+        Char c = p != end ? *p : Char();
+        if (c == '}') {
+          handler.on_replacement_field(p);
+        }
+        else if (c == ':') {
+          p = handler.on_format_specs(p + 1, end);
+          if (p == end || *p != '}')
+            return handler.on_error("unknown format specifier");
+        }
+        else {
+          return handler.on_error("missing '}' in format string");
+        }
+      }
+      begin = p + 1;
     }
-    begin = p + 1;
   }
-}
-
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
-    ParseContext& ctx) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type =
-      conditional_t<internal::mapped_type_constant<T, context>::value !=
-                        internal::custom_type,
-                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
-  conditional_t<has_formatter<mapped_type, context>::value,
-                formatter<mapped_type, char_type>,
-                internal::fallback_formatter<T, char_type>>
-      f;
-  return f.parse(ctx);
-}
 
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
-  explicit FMT_CONSTEXPR format_string_checker(
-      basic_string_view<Char> format_str, ErrorHandler eh)
-      : arg_id_((std::numeric_limits<unsigned>::max)()),
-        context_(format_str, eh),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+  template <typename T, typename ParseContext>
+  FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx)
+  {
+    using char_type = typename ParseContext::char_type;
+    using context   = buffer_context<char_type>;
+    using mapped_type =
+        conditional_t<internal::mapped_type_constant<T, context>::value != internal::custom_type,
+                      decltype(arg_mapper<context>().map(std::declval<T>())), T>;
+    auto f =
+        conditional_t<has_formatter<mapped_type, context>::value, formatter<mapped_type, char_type>,
+                      internal::fallback_formatter<T, char_type>>();
+    return f.parse(ctx);
+  }
+
+  template <typename Char, typename ErrorHandler, typename... Args> class format_string_checker
+  {
+  public:
+    explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> format_str,
+                                                 ErrorHandler            eh)
+        : arg_id_(max_value<unsigned>()),
+          context_(format_str, eh), parse_funcs_{&parse_format_specs<Args, parse_context_type>...}
+    {
+    }
 
-  FMT_CONSTEXPR void on_arg_id() {
-    arg_id_ = context_.next_arg_id();
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(int id) {
-    arg_id_ = id;
-    context_.check_arg_id(id);
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
-    on_error("compile-time checks don't support named arguments");
-  }
+    FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
 
-  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
+    FMT_CONSTEXPR void on_arg_id()
+    {
+      arg_id_ = context_.next_arg_id();
+      check_arg_id();
+    }
+    FMT_CONSTEXPR void on_arg_id(int id)
+    {
+      arg_id_ = id;
+      context_.check_arg_id(id);
+      check_arg_id();
+    }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>)
+    {
+      on_error("compile-time checks don't support named arguments");
+    }
 
-  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
-    advance_to(context_, begin);
-    return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
-  }
+    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
+    FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *)
+    {
+      advance_to(context_, begin);
+      return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
+    }
 
- private:
-  using parse_context_type = basic_parse_context<Char, ErrorHandler>;
-  enum { num_args = sizeof...(Args) };
+    FMT_CONSTEXPR void on_error(const char *message) { context_.on_error(message); }
 
-  FMT_CONSTEXPR void check_arg_id() {
-    if (arg_id_ >= num_args) context_.on_error("argument index out of range");
-  }
+  private:
+    using parse_context_type = basic_parse_context<Char, ErrorHandler>;
+    enum { num_args = sizeof...(Args) };
 
-  // Format specifier parsing function.
-  using parse_func = const Char* (*)(parse_context_type&);
+    FMT_CONSTEXPR void check_arg_id()
+    {
+      if (arg_id_ >= num_args)
+        context_.on_error("argument index out of range");
+    }
 
-  unsigned arg_id_;
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
-};
+    // Format specifier parsing function.
+    using parse_func = const Char *(*)(parse_context_type &);
 
-template <typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
-                                          ErrorHandler eh = ErrorHandler()) {
-  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
-  parse_format_string<true>(s, checker);
-  return true;
-}
+    unsigned           arg_id_;
+    parse_context_type context_;
+    parse_func         parse_funcs_[num_args > 0 ? num_args : 1];
+  };
 
-template <typename... Args, typename S,
-          enable_if_t<(is_compile_string<S>::value), int>>
-void check_format_string(S format_str) {
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      internal::do_check_format_string<typename S::char_type,
-                                       internal::error_handler, Args...>(
-          to_string_view(format_str));
-  (void)invalid_format;
-}
+  template <typename Char, typename ErrorHandler, typename... Args>
+  FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
+                                            ErrorHandler            eh = ErrorHandler())
+  {
+    format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
+    parse_format_string<true>(s, checker);
+    return true;
+  }
 
-template <template <typename> class Handler, typename Spec, typename Context>
-void handle_dynamic_spec(Spec& value, arg_ref<typename Context::char_type> ref,
-                         Context& ctx,
-                         const typename Context::char_type* format_str) {
-  switch (ref.kind) {
-  case arg_id_kind::none:
-    break;
-  case arg_id_kind::index:
-    internal::set_dynamic_spec<Handler>(value, ctx.arg(ref.val.index),
-                                        ctx.error_handler());
-    break;
-  case arg_id_kind::name: {
-    const auto arg_id = ref.val.name.to_view(format_str);
-    internal::set_dynamic_spec<Handler>(value, ctx.arg(arg_id),
-                                        ctx.error_handler());
-    break;
+  template <typename... Args, typename S, enable_if_t<(is_compile_string<S>::value), int>>
+  void check_format_string(S format_str)
+  {
+    FMT_CONSTEXPR_DECL bool invalid_format =
+        internal::do_check_format_string<typename S::char_type, internal::error_handler, Args...>(
+            to_string_view(format_str));
+    (void)invalid_format;
   }
+
+  template <template <typename> class Handler, typename Context>
+  void handle_dynamic_spec(int &value, arg_ref<typename Context::char_type> ref, Context &ctx)
+  {
+    switch (ref.kind) {
+    case arg_id_kind::none: break;
+    case arg_id_kind::index:
+      value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index), ctx.error_handler());
+      break;
+    case arg_id_kind::name:
+      value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name), ctx.error_handler());
+      break;
+    }
   }
-}
-}  // namespace internal
+} // namespace internal
 
-template <typename Range>
-using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
-using writer FMT_DEPRECATED_ALIAS = internal::writer;
-using wwriter FMT_DEPRECATED_ALIAS =
-    internal::basic_writer<internal::buffer_range<wchar_t>>;
+template <typename Range> using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
+using writer                                 FMT_DEPRECATED_ALIAS = internal::writer;
+using wwriter FMT_DEPRECATED_ALIAS = internal::basic_writer<buffer_range<wchar_t>>;
 
 /** The default argument formatter. */
-template <typename Range>
-class arg_formatter : public internal::arg_formatter_base<Range> {
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
+template <typename Range> class arg_formatter : public internal::arg_formatter_base<Range>
+{
+private:
+  using char_type    = typename Range::value_type;
+  using base         = internal::arg_formatter_base<Range>;
   using context_type = basic_format_context<typename base::iterator, char_type>;
 
-  context_type& ctx_;
-  basic_parse_context<char_type>* parse_ctx_;
+  context_type &                  ctx_;
+  basic_parse_context<char_type> *parse_ctx_;
 
- public:
-  using range = Range;
-  using iterator = typename base::iterator;
+public:
+  using range        = Range;
+  using iterator     = typename base::iterator;
   using format_specs = typename base::format_specs;
 
   /**
@@ -2623,19 +2799,19 @@ class arg_formatter : public internal::arg_formatter_base<Range> {
     *specs* contains format specifier information for standard argument types.
     \endrst
    */
-  explicit arg_formatter(context_type& ctx,
-                         basic_parse_context<char_type>* parse_ctx = nullptr,
-                         format_specs* f_specs = nullptr)
-      : base(Range(ctx.out()), f_specs, ctx.locale()),
-        ctx_(ctx),
-        parse_ctx_(parse_ctx) {}
+  explicit arg_formatter(context_type &ctx, basic_parse_context<char_type> *parse_ctx = nullptr,
+                         format_specs *specs = nullptr)
+      : base(Range(ctx.out()), specs, ctx.locale()), ctx_(ctx), parse_ctx_(parse_ctx)
+  {
+  }
 
   using base::operator();
 
   /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+  iterator operator()(typename basic_format_arg<context_type>::handle handle)
+  {
     handle.format(*parse_ctx_, ctx_);
-    return this->out();
+    return ctx_.out();
   }
 };
 
@@ -2643,16 +2819,17 @@ class arg_formatter : public internal::arg_formatter_base<Range> {
  An error returned by an operating system or a language runtime,
  for example a file opening error.
 */
-class FMT_API system_error : public std::runtime_error {
- private:
+class FMT_API system_error : public std::runtime_error
+{
+private:
   void init(int err_code, string_view format_str, format_args args);
 
- protected:
+protected:
   int error_code_;
 
   system_error() : std::runtime_error(""), error_code_(0) {}
 
- public:
+public:
   /**
    \rst
    Constructs a :class:`fmt::system_error` object with a description
@@ -2672,10 +2849,14 @@ class FMT_API system_error : public std::runtime_error {
    \endrst
   */
   template <typename... Args>
-  system_error(int p_error_code, string_view message, const Args&... args)
-      : std::runtime_error("") {
-    init(p_error_code, message, make_format_args(args...));
+  system_error(int error_code, string_view message, const Args &... args) : std::runtime_error("")
+  {
+    init(error_code, message, make_format_args(args...));
   }
+  system_error(const system_error &) = default;
+  system_error &operator=(const system_error &) = default;
+  system_error(system_error &&)                 = default;
+  system_error &operator=(system_error &&) = default;
   ~system_error() FMT_NOEXCEPT;
 
   int error_code() const { return error_code_; }
@@ -2697,10 +2878,11 @@ class FMT_API system_error : public std::runtime_error {
   may look like "Unknown error -1" and is platform-dependent.
   \endrst
  */
-FMT_API void format_system_error(internal::buffer<char>& out, int error_code,
+FMT_API void format_system_error(internal::buffer<char> &out, int error_code,
                                  fmt::string_view message) FMT_NOEXCEPT;
 
-struct float_spec_handler {
+struct float_spec_handler
+{
   char type;
   bool upper;
   bool fixed;
@@ -2708,130 +2890,137 @@ struct float_spec_handler {
   bool use_locale;
 
   explicit float_spec_handler(char t)
-      : type(t),
-        upper(false),
-        fixed(false),
-        as_percentage(false),
-        use_locale(false) {}
+      : type(t), upper(false), fixed(false), as_percentage(false), use_locale(false)
+  {
+  }
 
-  void on_general() {
-    if (type == 'G') upper = true;
+  void on_general()
+  {
+    if (type == 'G')
+      upper = true;
   }
 
-  void on_exp() {
-    if (type == 'E') upper = true;
+  void on_exp()
+  {
+    if (type == 'E')
+      upper = true;
   }
 
-  void on_fixed() {
+  void on_fixed()
+  {
     fixed = true;
-    if (type == 'F') upper = true;
+    if (type == 'F')
+      upper = true;
   }
 
-  void on_percent() {
-    fixed = true;
+  void on_percent()
+  {
+    fixed         = true;
     as_percentage = true;
   }
 
-  void on_hex() {
-    if (type == 'A') upper = true;
+  void on_hex()
+  {
+    if (type == 'A')
+      upper = true;
   }
 
   void on_num() { use_locale = true; }
 
-  FMT_NORETURN void on_error() {
-    FMT_THROW(format_error("invalid type specifier"));
-  }
+  FMT_NORETURN void on_error() { FMT_THROW(format_error("invalid type specifier")); }
 };
 
 template <typename Range>
 template <typename T, bool USE_GRISU>
-void internal::basic_writer<Range>::write_double(T value,
-                                                 const format_specs& specs) {
+void internal::basic_writer<Range>::write_fp(T value, const format_specs &specs)
+{
   // Check type.
   float_spec_handler handler(static_cast<char>(specs.type));
-  internal::handle_float_type_spec(handler.type, handler);
+  handle_float_type_spec(handler.type, handler);
 
-  char sign = 0;
+  auto sign = specs.sign;
   // Use signbit instead of value < 0 since the latter is always false for NaN.
   if (std::signbit(value)) {
-    sign = '-';
+    sign  = sign::minus;
     value = -value;
-  } else if (specs.sign != sign::none) {
-    if (specs.sign == sign::plus)
-      sign = '+';
-    else if (specs.sign == sign::space)
-      sign = ' ';
+  }
+  else if (sign == sign::minus) {
+    sign = sign::none;
   }
 
   if (!std::isfinite(value)) {
-    // Format infinity and NaN ourselves because sprintf's output is not
-    // consistent across platforms.
-    const char* str = std::isinf(value) ? (handler.upper ? "INF" : "inf")
-                                        : (handler.upper ? "NAN" : "nan");
-    return write_padded(specs,
-                        inf_or_nan_writer{sign, handler.as_percentage, str});
+    const char *str =
+        std::isinf(value) ? (handler.upper ? "INF" : "inf") : (handler.upper ? "NAN" : "nan");
+    return write_padded(specs, inf_or_nan_writer{sign, handler.as_percentage, str});
   }
 
-  if (handler.as_percentage) value *= 100;
+  if (handler.as_percentage)
+    value *= 100;
 
   memory_buffer buffer;
-  int exp = 0;
-  int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
-  unsigned options = handler.fixed ? internal::grisu_options::fixed : 0;
-  bool use_grisu = USE_GRISU &&
-                   (specs.type != 'a' && specs.type != 'A' &&
-                    specs.type != 'e' && specs.type != 'E') &&
-                   internal::grisu_format(static_cast<double>(value), buffer,
-                                          precision, options, exp);
-  char* decimal_point_pos = nullptr;
+  int           exp       = 0;
+  int           precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
+  unsigned      options   = 0;
+  if (handler.fixed)
+    options |= grisu_options::fixed;
+  if (const_check(sizeof(value) == sizeof(float)))
+    options |= grisu_options::binary32;
+  bool use_grisu =
+      USE_GRISU &&
+      (specs.type != 'a' && specs.type != 'A' && specs.type != 'e' && specs.type != 'E') &&
+      grisu_format(static_cast<double>(value), buffer, precision, options, exp);
+  char *decimal_point_pos = nullptr;
   if (!use_grisu)
-    decimal_point_pos = internal::sprintf_format(value, buffer, specs);
+    decimal_point_pos = sprintf_format(value, buffer, specs);
 
   if (handler.as_percentage) {
     buffer.push_back('%');
-    --exp;  // Adjust decimal place position.
+    --exp; // Adjust decimal place position.
   }
   format_specs as = specs;
   if (specs.align == align::numeric) {
     if (sign) {
-      auto&& it = reserve(1);
-      *it++ = static_cast<char_type>(sign);
-      sign = 0;
-      if (as.width) --as.width;
+      auto &&it = reserve(1);
+      *it++     = static_cast<char_type>(data::signs[sign]);
+      sign      = sign::none;
+      if (as.width)
+        --as.width;
     }
     as.align = align::right;
-  } else if (specs.align == align::none) {
+  }
+  else if (specs.align == align::none) {
     as.align = align::right;
   }
-  char_type decimal_point = handler.use_locale
-                                ? internal::decimal_point<char_type>(locale_)
-                                : static_cast<char_type>('.');
+  char_type decimal_point = handler.use_locale ? internal::decimal_point<char_type>(locale_)
+                                               : static_cast<char_type>('.');
   if (use_grisu) {
-    auto params = internal::gen_digits_params();
-    params.fixed = handler.fixed;
-    params.num_digits = precision;
-    params.trailing_zeros =
-        (precision != 0 && (handler.fixed || !specs.type)) || specs.alt;
-    write_padded(as, grisu_writer(sign, buffer, exp, params, decimal_point));
-  } else {
+    auto params           = gen_digits_params();
+    params.sign           = sign;
+    params.fixed          = handler.fixed;
+    params.num_digits     = precision;
+    params.trailing_zeros = (precision != 0 && (handler.fixed || !specs.type)) || specs.alt;
+    int num_digits        = static_cast<int>(buffer.size());
     write_padded(as,
-                 double_writer{sign, buffer, decimal_point_pos, decimal_point});
+                 grisu_writer<char_type>(buffer.data(), num_digits, exp, params, decimal_point));
+  }
+  else {
+    write_padded(as, double_writer{sign, buffer, decimal_point_pos, decimal_point});
   }
 }
 
 // Reports a system error without throwing an exception.
 // Can be used to report errors from destructors.
-FMT_API void report_system_error(int error_code,
-                                 string_view message) FMT_NOEXCEPT;
+FMT_API void report_system_error(int error_code, string_view message) FMT_NOEXCEPT;
 
 #if FMT_USE_WINDOWS_H
 
 /** A Windows error. */
-class windows_error : public system_error {
- private:
+class windows_error : public system_error
+{
+private:
   FMT_API void init(int error_code, string_view format_str, format_args args);
 
- public:
+public:
   /**
    \rst
    Constructs a :class:`fmt::windows_error` object with the description
@@ -2861,30 +3050,32 @@ class windows_error : public system_error {
    \endrst
   */
   template <typename... Args>
-  windows_error(int error_code, string_view message, const Args&... args) {
+  windows_error(int error_code, string_view message, const Args &... args)
+  {
     init(error_code, message, make_format_args(args...));
   }
 };
 
 // Reports a Windows error without throwing an exception.
 // Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code,
-                                  string_view message) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code, string_view message) FMT_NOEXCEPT;
 
 #endif
 
 /** Fast integer formatter. */
-class format_int {
- private:
+class format_int
+{
+private:
   // Buffer should be large enough to hold all digits (digits10 + 1),
   // a sign and a null character.
   enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
   mutable char buffer_[buffer_size];
-  char* str_;
+  char *       str_;
 
   // Formats value in reverse and returns a pointer to the beginning.
-  char* format_decimal(unsigned long long value) {
-    char* ptr = buffer_ + (buffer_size - 1);  // Parens to workaround MSVC bug.
+  char *format_decimal(unsigned long long value)
+  {
+    char *ptr = buffer_ + (buffer_size - 1); // Parens to workaround MSVC bug.
     while (value >= 100) {
       // Integer division is slow so do it for a group of two digits instead
       // of for every digit. The idea comes from the talk by Alexandrescu
@@ -2899,20 +3090,23 @@ class format_int {
       return ptr;
     }
     unsigned index = static_cast<unsigned>(value * 2);
-    *--ptr = internal::data::digits[index + 1];
-    *--ptr = internal::data::digits[index];
+    *--ptr         = internal::data::digits[index + 1];
+    *--ptr         = internal::data::digits[index];
     return ptr;
   }
 
-  void format_signed(long long value) {
+  void format_signed(long long value)
+  {
     unsigned long long abs_value = static_cast<unsigned long long>(value);
-    bool negative = value < 0;
-    if (negative) abs_value = 0 - abs_value;
+    bool               negative  = value < 0;
+    if (negative)
+      abs_value = 0 - abs_value;
     str_ = format_decimal(abs_value);
-    if (negative) *--str_ = '-';
+    if (negative)
+      *--str_ = '-';
   }
 
- public:
+public:
   explicit format_int(int value) { format_signed(value); }
   explicit format_int(long value) { format_signed(value); }
   explicit format_int(long long value) { format_signed(value); }
@@ -2921,21 +3115,20 @@ class format_int {
   explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
 
   /** Returns the number of characters written to the output buffer. */
-  std::size_t size() const {
-    return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
-  }
+  std::size_t size() const { return internal::to_unsigned(buffer_ - str_ + buffer_size - 1); }
 
   /**
     Returns a pointer to the output buffer content. No terminating null
     character is appended.
    */
-  const char* data() const { return str_; }
+  const char *data() const { return str_; }
 
   /**
     Returns a pointer to the output buffer content with terminating null
     character appended.
    */
-  const char* c_str() const {
+  const char *c_str() const
+  {
     buffer_[buffer_size - 1] = '\0';
     return str_;
   }
@@ -2952,53 +3145,46 @@ class format_int {
 // constants.
 template <typename T, typename Char>
 struct formatter<T, Char,
-                 enable_if_t<internal::type_constant<T, Char>::value !=
-                             internal::custom_type>> {
-  FMT_CONSTEXPR formatter() : format_str_(nullptr) {}
+                 enable_if_t<internal::type_constant<T, Char>::value != internal::custom_type>>
+{
+  FMT_CONSTEXPR formatter() {}
 
   // Parses format specifiers stopping either at the end of the range or at the
   // terminating '}'.
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    format_str_ = ctx.begin();
-    using handler_type = internal::dynamic_specs_handler<ParseContext>;
-    auto type = internal::type_constant<T, Char>::value;
-    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
-                                                  type);
-    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
-    auto eh = ctx.error_handler();
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
+    using handler_type                         = internal::dynamic_specs_handler<ParseContext>;
+    auto                                  type = internal::type_constant<T, Char>::value;
+    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx), type);
+    auto                                  it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    auto                                  eh = ctx.error_handler();
     switch (type) {
     case internal::none_type:
-    case internal::named_arg_type:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
+    case internal::named_arg_type: FMT_ASSERT(false, "invalid argument type"); break;
     case internal::int_type:
     case internal::uint_type:
     case internal::long_long_type:
     case internal::ulong_long_type:
+    case internal::int128_type:
+    case internal::uint128_type:
     case internal::bool_type:
-      handle_int_type_spec(specs_.type,
-                           internal::int_type_checker<decltype(eh)>(eh));
+      handle_int_type_spec(specs_.type, internal::int_type_checker<decltype(eh)>(eh));
       break;
     case internal::char_type:
-      handle_char_specs(
-          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
+      handle_char_specs(&specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
       break;
+    case internal::float_type:
     case internal::double_type:
     case internal::long_double_type:
-      handle_float_type_spec(specs_.type,
-                             internal::float_type_checker<decltype(eh)>(eh));
+      handle_float_type_spec(specs_.type, internal::float_type_checker<decltype(eh)>(eh));
       break;
     case internal::cstring_type:
-      internal::handle_cstring_type_spec(
-          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::string_type:
-      internal::check_string_type_spec(specs_.type, eh);
-      break;
-    case internal::pointer_type:
-      internal::check_pointer_type_spec(specs_.type, eh);
+      internal::handle_cstring_type_spec(specs_.type,
+                                         internal::cstring_type_checker<decltype(eh)>(eh));
       break;
+    case internal::string_type: internal::check_string_type_spec(specs_.type, eh); break;
+    case internal::pointer_type: internal::check_pointer_type_spec(specs_.type, eh); break;
     case internal::custom_type:
       // Custom format specifiers should be checked in parse functions of
       // formatter specializations.
@@ -3008,30 +3194,29 @@ struct formatter<T, Char,
   }
 
   template <typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx, format_str_);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx, format_str_);
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+  {
+    internal::handle_dynamic_spec<internal::width_checker>(specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision,
+                                                               specs_.precision_ref, ctx);
     using range_type =
-        internal::output_range<typename FormatContext::iterator,
-                               typename FormatContext::char_type>;
+        internal::output_range<typename FormatContext::iterator, typename FormatContext::char_type>;
     return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
                             internal::make_arg<FormatContext>(val));
   }
 
- private:
+private:
   internal::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
 };
 
-#define FMT_FORMAT_AS(Type, Base)                                             \
-  template <typename Char>                                                    \
-  struct formatter<Type, Char> : formatter<Base, Char> {                      \
-    template <typename FormatContext>                                         \
-    auto format(const Type& val, FormatContext& ctx) -> decltype(ctx.out()) { \
-      return formatter<Base, Char>::format(val, ctx);                         \
-    }                                                                         \
+#define FMT_FORMAT_AS(Type, Base)                                                                  \
+  template <typename Char> struct formatter<Type, Char> : formatter<Base, Char>                    \
+  {                                                                                                \
+    template <typename FormatContext>                                                              \
+    auto format(const Type &val, FormatContext &ctx) -> decltype(ctx.out())                        \
+    {                                                                                              \
+      return formatter<Base, Char>::format(val, ctx);                                              \
+    }                                                                                              \
   }
 
 FMT_FORMAT_AS(signed char, int);
@@ -3040,24 +3225,26 @@ FMT_FORMAT_AS(short, int);
 FMT_FORMAT_AS(unsigned short, unsigned);
 FMT_FORMAT_AS(long, long long);
 FMT_FORMAT_AS(unsigned long, unsigned long long);
-FMT_FORMAT_AS(float, double);
-FMT_FORMAT_AS(Char*, const Char*);
+FMT_FORMAT_AS(Char *, const Char *);
 FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
-FMT_FORMAT_AS(std::nullptr_t, const void*);
+FMT_FORMAT_AS(std::nullptr_t, const void *);
 FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);
 
-template <typename Char>
-struct formatter<void*, Char> : formatter<const void*, Char> {
+template <typename Char> struct formatter<void *, Char> : formatter<const void *, Char>
+{
   template <typename FormatContext>
-  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
-    return formatter<const void*, Char>::format(val, ctx);
+  auto format(void *val, FormatContext &ctx) -> decltype(ctx.out())
+  {
+    return formatter<const void *, Char>::format(val, ctx);
   }
 };
 
 template <typename Char, size_t N>
-struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char>
+{
   template <typename FormatContext>
-  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const Char *val, FormatContext &ctx) -> decltype(ctx.out())
+  {
     return formatter<basic_string_view<Char>, Char>::format(val, ctx);
   }
 };
@@ -3072,9 +3259,11 @@ struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
 //       visit([&](const auto &val) { format(buf, val, ctx); }, v);
 //     }
 //   };
-template <typename Char = char> class dynamic_formatter {
- private:
-  struct null_handler : internal::error_handler {
+template <typename Char = char> class dynamic_formatter
+{
+private:
+  struct null_handler : internal::error_handler
+  {
     void on_align(align_t) {}
     void on_plus() {}
     void on_minus() {}
@@ -3082,9 +3271,9 @@ template <typename Char = char> class dynamic_formatter {
     void on_hash() {}
   };
 
- public:
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+public:
+  template <typename ParseContext> auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     format_str_ = ctx.begin();
     // Checks are deferred to formatting time when the argument type is known.
     internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
@@ -3092,124 +3281,124 @@ template <typename Char = char> class dynamic_formatter {
   }
 
   template <typename T, typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+  {
     handle_specs(ctx);
     internal::specs_checker<null_handler> checker(
-        null_handler(),
-        internal::mapped_type_constant<T, FormatContext>::value);
+        null_handler(), internal::mapped_type_constant<T, FormatContext>::value);
     checker.on_align(specs_.align);
     switch (specs_.sign) {
-    case sign::none:
-      break;
-    case sign::plus:
-      checker.on_plus();
-      break;
-    case sign::minus:
-      checker.on_minus();
-      break;
-    case sign::space:
-      checker.on_space();
-      break;
+    case sign::none: break;
+    case sign::plus: checker.on_plus(); break;
+    case sign::minus: checker.on_minus(); break;
+    case sign::space: checker.on_space(); break;
     }
-    if (specs_.alt) checker.on_hash();
-    if (specs_.precision >= 0) checker.end_precision();
-    using range = internal::output_range<typename FormatContext::iterator,
-                                         typename FormatContext::char_type>;
+    if (specs_.alt)
+      checker.on_hash();
+    if (specs_.precision >= 0)
+      checker.end_precision();
+    using range =
+        internal::output_range<typename FormatContext::iterator, typename FormatContext::char_type>;
     visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
                      internal::make_arg<FormatContext>(val));
     return ctx.out();
   }
 
- private:
-  template <typename Context> void handle_specs(Context& ctx) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx, format_str_);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx, format_str_);
+private:
+  template <typename Context> void handle_specs(Context &ctx)
+  {
+    internal::handle_dynamic_spec<internal::width_checker>(specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision,
+                                                               specs_.precision_ref, ctx);
   }
 
   internal::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
+  const Char *                         format_str_;
 };
 
 template <typename Range, typename Char>
 typename basic_format_context<Range, Char>::format_arg
-basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
+basic_format_context<Range, Char>::arg(basic_string_view<char_type> name)
+{
   map_.init(args_);
-  format_arg f_arg = map_.find(name);
-  if (f_arg.type() == internal::none_type) this->on_error("argument not found");
-  return f_arg;
+  format_arg arg = map_.find(name);
+  if (arg.type() == internal::none_type)
+    this->on_error("argument not found");
+  return arg;
 }
 
 template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void advance_to(basic_parse_context<Char, ErrorHandler>& ctx,
-                              const Char* p) {
+FMT_CONSTEXPR void advance_to(basic_parse_context<Char, ErrorHandler> &ctx, const Char *p)
+{
   ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
 }
 
 template <typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler {
+struct format_handler : internal::error_handler
+{
   using range = typename ArgFormatter::range;
 
-  format_handler(range r, basic_string_view<Char> str,
-                 basic_format_args<Context> format_args,
+  format_handler(range r, basic_string_view<Char> str, basic_format_args<Context> format_args,
                  internal::locale_ref loc)
-      : parse_context(str), context(r.begin(), format_args, loc) {}
+      : parse_context(str), context(r.begin(), format_args, loc)
+  {
+  }
 
-  void on_text(const Char* begin, const Char* end) {
-    auto size = internal::to_unsigned(end - begin);
-    auto out = context.out();
-    auto&& it = internal::reserve(out, size);
-    it = std::copy_n(begin, size, it);
+  void on_text(const Char *begin, const Char *end)
+  {
+    auto   size = internal::to_unsigned(end - begin);
+    auto   out  = context.out();
+    auto &&it   = internal::reserve(out, size);
+    it          = std::copy_n(begin, size, it);
     context.advance_to(out);
   }
 
   void get_arg(int id) { arg = internal::get_arg(context, id); }
 
   void on_arg_id() { get_arg(parse_context.next_arg_id()); }
-  void on_arg_id(int id) {
+  void on_arg_id(int id)
+  {
     parse_context.check_arg_id(id);
     get_arg(id);
   }
   void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
 
-  void on_replacement_field(const Char* p) {
+  void on_replacement_field(const Char *p)
+  {
     advance_to(parse_context, p);
-    internal::custom_formatter<Context> f(parse_context, context);
-    if (!visit_format_arg(f, arg))
-      context.advance_to(
-          visit_format_arg(ArgFormatter(context, &parse_context), arg));
+    context.advance_to(visit_format_arg(ArgFormatter(context, &parse_context), arg));
   }
 
-  const Char* on_format_specs(const Char* begin, const Char* end) {
+  const Char *on_format_specs(const Char *begin, const Char *end)
+  {
     advance_to(parse_context, begin);
     internal::custom_formatter<Context> f(parse_context, context);
-    if (visit_format_arg(f, arg)) return parse_context.begin();
+    if (visit_format_arg(f, arg))
+      return parse_context.begin();
     basic_format_specs<Char> specs;
     using internal::specs_handler;
     using parse_context_t = basic_parse_context<Char>;
     internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
-        specs_handler<parse_context_t, Context>(specs, parse_context, context),
-        arg.type());
+        specs_handler<parse_context_t, Context>(specs, parse_context, context), arg.type());
     begin = parse_format_specs(begin, end, handler);
-    if (begin == end || *begin != '}') on_error("missing '}' in format string");
+    if (begin == end || *begin != '}')
+      on_error("missing '}' in format string");
     advance_to(parse_context, begin);
-    context.advance_to(
-        visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
+    context.advance_to(visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
     return begin;
   }
 
   basic_parse_context<Char> parse_context;
-  Context context;
+  Context                   context;
   basic_format_arg<Context> arg;
 };
 
 /** Formats arguments and writes the output to the range. */
 template <typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator vformat_to(
-    typename ArgFormatter::range out, basic_string_view<Char> format_str,
-    basic_format_args<Context> args,
-    internal::locale_ref loc = internal::locale_ref()) {
+typename Context::iterator
+vformat_to(typename ArgFormatter::range out, basic_string_view<Char> format_str,
+           basic_format_args<Context> args, internal::locale_ref loc = internal::locale_ref())
+{
   format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
   internal::parse_format_string<false>(format_str, h);
   return h.context.out();
@@ -3218,17 +3407,14 @@ typename Context::iterator vformat_to(
 // Casts ``p`` to ``const void*`` for pointer formatting.
 // Example:
 //   auto s = format("{}", ptr(p));
-template <typename T> inline const void* ptr(const T* p) { return p; }
-template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
-  return p.get();
-}
-template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
-  return p.get();
-}
-
-template <typename It, typename Char> struct arg_join : internal::view {
-  It begin;
-  It end;
+template <typename T> inline const void *ptr(const T *p) { return p; }
+template <typename T> inline const void *ptr(const std::unique_ptr<T> &p) { return p.get(); }
+template <typename T> inline const void *ptr(const std::shared_ptr<T> &p) { return p.get(); }
+
+template <typename It, typename Char> struct arg_join : internal::view
+{
+  It                      begin;
+  It                      end;
   basic_string_view<Char> sep;
 
   arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
@@ -3236,13 +3422,14 @@ template <typename It, typename Char> struct arg_join : internal::view {
 
 template <typename It, typename Char>
 struct formatter<arg_join<It, Char>, Char>
-    : formatter<typename std::iterator_traits<It>::value_type, Char> {
+    : formatter<typename std::iterator_traits<It>::value_type, Char>
+{
   template <typename FormatContext>
-  auto format(const arg_join<It, Char>& value, FormatContext& ctx)
-      -> decltype(ctx.out()) {
+  auto format(const arg_join<It, Char> &value, FormatContext &ctx) -> decltype(ctx.out())
+  {
     using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
-    auto it = value.begin;
-    auto out = ctx.out();
+    auto it    = value.begin;
+    auto out   = ctx.out();
     if (it != value.end) {
       out = base::format(*it++, ctx);
       while (it != value.end) {
@@ -3259,13 +3446,13 @@ struct formatter<arg_join<It, Char>, Char>
   Returns an object that formats the iterator range `[begin, end)` with elements
   separated by `sep`.
  */
-template <typename It>
-arg_join<It, char> join(It begin, It end, string_view sep) {
+template <typename It> arg_join<It, char> join(It begin, It end, string_view sep)
+{
   return {begin, end, sep};
 }
 
-template <typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
+template <typename It> arg_join<It, wchar_t> join(It begin, It end, wstring_view sep)
+{
   return {begin, end, sep};
 }
 
@@ -3281,14 +3468,14 @@ arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
   \endrst
  */
 template <typename Range>
-arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
-                                                       string_view sep) {
+arg_join<internal::iterator_t<const Range>, char> join(const Range &range, string_view sep)
+{
   return join(std::begin(range), std::end(range), sep);
 }
 
 template <typename Range>
-arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
-                                                          wstring_view sep) {
+arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range &range, wstring_view sep)
+{
   return join(std::begin(range), std::end(range), sep);
 }
 
@@ -3304,43 +3491,44 @@ arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
     std::string answer = fmt::to_string(42);
   \endrst
  */
-template <typename T> inline std::string to_string(const T& value) {
-  return format("{}", value);
-}
+template <typename T> inline std::string to_string(const T &value) { return format("{}", value); }
 
 /**
   Converts *value* to ``std::wstring`` using the default format for type *T*.
  */
-template <typename T> inline std::wstring to_wstring(const T& value) {
+template <typename T> inline std::wstring to_wstring(const T &value)
+{
   return format(L"{}", value);
 }
 
 template <typename Char, std::size_t SIZE>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
+std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE> &buf)
+{
   return std::basic_string<Char>(buf.data(), buf.size());
 }
 
 template <typename Char>
-typename buffer_context<Char>::iterator internal::vformat_to(
-    internal::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
+typename buffer_context<Char>::iterator
+internal::vformat_to(internal::buffer<Char> &buf, basic_string_view<Char> format_str,
+                     basic_format_args<buffer_context<Char>> args)
+{
   using range = buffer_range<Char>;
-  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
-                                          args);
+  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args);
 }
 
-template <typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline typename buffer_context<Char>::iterator vformat_to(
-    internal::buffer<Char>& buf, const S& format_str,
-    basic_format_args<buffer_context<Char>> args) {
+template <typename S, typename Char = char_t<S>, FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline typename buffer_context<Char>::iterator
+vformat_to(internal::buffer<Char> &buf, const S &format_str,
+           basic_format_args<buffer_context<Char>> args)
+{
   return internal::vformat_to(buf, to_string_view(format_str), args);
 }
 
 template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline typename buffer_context<Char>::iterator format_to(
-    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
+inline typename buffer_context<Char>::iterator format_to(basic_memory_buffer<Char, SIZE> &buf,
+                                                         const S &format_str, Args &&... args)
+{
   internal::check_format_string<Args...>(format_str);
   using context = buffer_context<Char>;
   return internal::vformat_to(buf, to_string_view(format_str),
@@ -3354,14 +3542,13 @@ template <typename OutputIt, typename Char = char>
 using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
 
 template <typename S, typename OutputIt, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
-inline OutputIt vformat_to(OutputIt out, const S& format_str,
-                           format_args_t<OutputIt, char_t<S>> args) {
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value &&
+                        !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
+inline OutputIt vformat_to(OutputIt out, const S &format_str,
+                           format_args_t<OutputIt, char_t<S>> args)
+{
   using range = internal::output_range<OutputIt, char_t<S>>;
-  return vformat_to<arg_formatter<range>>(range(out),
-                                          to_string_view(format_str), args);
+  return vformat_to<arg_formatter<range>>(range(out), to_string_view(format_str), args);
 }
 
 /**
@@ -3376,18 +3563,18 @@ inline OutputIt vformat_to(OutputIt out, const S& format_str,
  \endrst
  */
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
-              internal::is_string<S>::value)>
-inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value &&
+                        !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
+                        internal::is_string<S>::value)>
+inline OutputIt format_to(OutputIt out, const S &format_str, Args &&... args)
+{
   internal::check_format_string<Args...>(format_str);
   using context = format_context_t<OutputIt, char_t<S>>;
-  return vformat_to(out, to_string_view(format_str),
-                    {make_format_args<context>(args...)});
+  return vformat_to(out, to_string_view(format_str), {make_format_args<context>(args...)});
 }
 
-template <typename OutputIt> struct format_to_n_result {
+template <typename OutputIt> struct format_to_n_result
+{
   /** Iterator past the end of the output range. */
   OutputIt out;
   /** Total (not truncated) output size. */
@@ -3395,26 +3582,25 @@ template <typename OutputIt> struct format_to_n_result {
 };
 
 template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_context =
-    format_context_t<fmt::internal::truncating_iterator<OutputIt>, Char>;
+using format_to_n_context = format_context_t<fmt::internal::truncating_iterator<OutputIt>, Char>;
 
 template <typename OutputIt, typename Char = typename OutputIt::value_type>
 using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
 
 template <typename OutputIt, typename Char, typename... Args>
 inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
-make_format_to_n_args(const Args&... args) {
-  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
-      args...);
+make_format_to_n_args(const Args &... args)
+{
+  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(args...);
 }
 
 template <typename OutputIt, typename Char, typename... Args,
           FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> vformat_to_n(
-    OutputIt out, std::size_t n, basic_string_view<Char> format_str,
-    format_to_n_args<OutputIt, Char> args) {
-  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
-                       format_str, args);
+inline format_to_n_result<OutputIt> vformat_to_n(OutputIt out, std::size_t n,
+                                                 basic_string_view<Char>          format_str,
+                                                 format_to_n_args<OutputIt, Char> args)
+{
+  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n), format_str, args);
   return {it.base(), it.count()};
 }
 
@@ -3425,22 +3611,21 @@ inline format_to_n_result<OutputIt> vformat_to_n(
  end of the output range.
  \endrst
  */
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value&&
-                            internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
-                                                const S& format_str,
-                                                const Args&... args) {
+template <
+    typename OutputIt, typename S, typename... Args,
+    FMT_ENABLE_IF(internal::is_string<S>::value &&internal::is_output_iterator<OutputIt>::value)>
+inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n, const S &format_str,
+                                                const Args &... args)
+{
   internal::check_format_string<Args...>(format_str);
   using context = format_to_n_context<OutputIt, char_t<S>>;
-  return vformat_to_n(out, n, to_string_view(format_str),
-                      {make_format_args<context>(args...)});
+  return vformat_to_n(out, n, to_string_view(format_str), {make_format_args<context>(args...)});
 }
 
 template <typename Char>
-inline std::basic_string<Char> internal::vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
+inline std::basic_string<Char> internal::vformat(basic_string_view<Char>                 format_str,
+                                                 basic_format_args<buffer_context<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   return fmt::to_string(buffer);
@@ -3451,100 +3636,106 @@ inline std::basic_string<Char> internal::vformat(
   ``format(format_str, args...)``.
  */
 template <typename... Args>
-inline std::size_t formatted_size(string_view format_str, const Args&... args) {
-  auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
+inline std::size_t formatted_size(string_view format_str, const Args &... args)
+{
+  auto it = format_to(internal::counting_iterator(), format_str, args...);
   return it.count();
 }
 
 #if FMT_USE_USER_DEFINED_LITERALS
 namespace internal {
 
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS> class udl_formatter {
- public:
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-    FMT_CONSTEXPR_DECL bool invalid_format =
-        do_check_format_string<Char, error_handler, Args...>(
-            basic_string_view<Char>(s, sizeof...(CHARS)));
-    (void)invalid_format;
-    return format(s, std::forward<Args>(args)...);
-  }
-};
-#  else
-template <typename Char> struct udl_formatter {
-  basic_string_view<Char> str;
+#if FMT_USE_UDL_TEMPLATE
+  template <typename Char, Char... CHARS> class udl_formatter
+  {
+  public:
+    template <typename... Args> std::basic_string<Char> operator()(Args &&... args) const
+    {
+      FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
+      FMT_CONSTEXPR_DECL bool invalid_format =
+          do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
+              basic_string_view<Char>(s, sizeof...(CHARS)));
+      (void)invalid_format;
+      return format(s, std::forward<Args>(args)...);
+    }
+  };
+#else
+  template <typename Char> struct udl_formatter
+  {
+    basic_string_view<Char> str;
 
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    return format(str, std::forward<Args>(args)...);
-  }
-};
-#  endif  // FMT_USE_UDL_TEMPLATE
+    template <typename... Args> std::basic_string<Char> operator()(Args &&... args) const
+    {
+      return format(str, std::forward<Args>(args)...);
+    }
+  };
+#endif // FMT_USE_UDL_TEMPLATE
 
-template <typename Char> struct udl_arg {
-  basic_string_view<Char> str;
+  template <typename Char> struct udl_arg
+  {
+    basic_string_view<Char> str;
 
-  template <typename T> named_arg<T, Char> operator=(T&& value) const {
-    return {str, std::forward<T>(value)};
-  }
-};
+    template <typename T> named_arg<T, Char> operator=(T &&value) const
+    {
+      return {str, std::forward<T>(value)};
+    }
+  };
 
-}  // namespace internal
+} // namespace internal
 
 inline namespace literals {
-#  if FMT_USE_UDL_TEMPLATE
-#    pragma GCC diagnostic push
-#    if FMT_CLANG_VERSION
-#      pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
-#    endif
-template <typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
-  return {};
-}
-#    pragma GCC diagnostic pop
-#  else
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::format`.
+#if FMT_USE_UDL_TEMPLATE
+#pragma GCC diagnostic push
+#if FMT_CLANG_VERSION
+#pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
+#endif
+  template <typename Char, Char... CHARS>
+  FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format()
+  {
+    return {};
+  }
+#pragma GCC diagnostic pop
+#else
+  /**
+    \rst
+    User-defined literal equivalent of :func:`fmt::format`.
 
-  **Example**::
+    **Example**::
 
-    using namespace fmt::literals;
-    std::string message = "The answer is {}"_format(42);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
-                                                               std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
-    const wchar_t* s, std::size_t n) {
-  return {{s, n}};
-}
-#  endif  // FMT_USE_UDL_TEMPLATE
+      using namespace fmt::literals;
+      std::string message = "The answer is {}"_format(42);
+    \endrst
+   */
+  FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+  FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(const wchar_t *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+#endif // FMT_USE_UDL_TEMPLATE
 
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::arg`.
+  /**
+    \rst
+    User-defined literal equivalent of :func:`fmt::arg`.
 
-  **Example**::
+    **Example**::
 
-    using namespace fmt::literals;
-    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
-                                                    std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
-                                                       std::size_t n) {
-  return {{s, n}};
-}
-}  // namespace literals
-#endif  // FMT_USE_USER_DEFINED_LITERALS
+      using namespace fmt::literals;
+      fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+    \endrst
+   */
+  FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+  FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+} // namespace literals
+#endif // FMT_USE_USER_DEFINED_LITERALS
 FMT_END_NAMESPACE
 
 /**
@@ -3557,19 +3748,20 @@ FMT_END_NAMESPACE
     std::string s = format(FMT_STRING("{:d}"), "foo");
   \endrst
  */
-#define FMT_STRING(s)                                                    \
-  [] {                                                                   \
-    struct str : fmt::compile_string {                                   \
-      using char_type = typename std::remove_cv<std::remove_pointer<     \
-          typename std::decay<decltype(s)>::type>::type>::type;          \
-      FMT_CONSTEXPR operator fmt::basic_string_view<char_type>() const { \
-        return {s, sizeof(s) / sizeof(char_type) - 1};                   \
-      }                                                                  \
-    } result;                                                            \
-    /* Suppress Qt Creator warning about unused operator. */             \
-    (void)static_cast<fmt::basic_string_view<typename str::char_type>>(  \
-        result);                                                         \
-    return result;                                                       \
+#define FMT_STRING(s)                                                                              \
+  [] {                                                                                             \
+    struct str : fmt::compile_string                                                               \
+    {                                                                                              \
+      using char_type = typename std::remove_cv<                                                   \
+          std::remove_pointer<typename std::decay<decltype(s)>::type>::type>::type;                \
+      FMT_CONSTEXPR operator fmt::basic_string_view<char_type>() const                             \
+      {                                                                                            \
+        return {s, sizeof(s) / sizeof(char_type) - 1};                                             \
+      }                                                                                            \
+    } result;                                                                                      \
+    /* Suppress Qt Creator warning about unused operator. */                                       \
+    (void)static_cast<fmt::basic_string_view<typename str::char_type>>(result);                    \
+    return result;                                                                                 \
   }()
 
 #if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
@@ -3587,14 +3779,14 @@ FMT_END_NAMESPACE
     std::string s = format(fmt("{:d}"), "foo");
   \endrst
  */
-#  define fmt(s) FMT_STRING(s)
+#define fmt(s) FMT_STRING(s)
 #endif
 
 #ifdef FMT_HEADER_ONLY
-#  define FMT_FUNC inline
-#  include "format-inl.h"
+#define FMT_FUNC inline
+#include "format-inl.h"
 #else
-#  define FMT_FUNC
+#define FMT_FUNC
 #endif
 
-#endif  // FMT_FORMAT_H_
+#endif // FMT_FORMAT_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/ostream.h b/packages/seacas/libraries/ioss/src/fmt/ostream.h
index 69bac0e24a13..c747f640d024 100644
--- a/packages/seacas/libraries/ioss/src/fmt/ostream.h
+++ b/packages/seacas/libraries/ioss/src/fmt/ostream.h
@@ -8,109 +8,118 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include <ostream>
 #include "format.h"
+#include <ostream>
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-template <class Char> class formatbuf : public std::basic_streambuf<Char> {
- private:
-  using int_type = typename std::basic_streambuf<Char>::int_type;
-  using traits_type = typename std::basic_streambuf<Char>::traits_type;
-
-  buffer<Char>& buffer_;
-
- public:
-  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
-
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
+  template <class Char> class formatbuf : public std::basic_streambuf<Char>
+  {
+  private:
+    using int_type    = typename std::basic_streambuf<Char>::int_type;
+    using traits_type = typename std::basic_streambuf<Char>::traits_type;
+
+    buffer<Char> &buffer_;
+
+  public:
+    formatbuf(buffer<Char> &buf) : buffer_(buf) {}
+
+  protected:
+    // The put-area is actually always empty. This makes the implementation
+    // simpler and has the advantage that the streambuf and the buffer are always
+    // in sync and sputc never writes into uninitialized memory. The obvious
+    // disadvantage is that each call to sputc always results in a (virtual) call
+    // to overflow. There is no disadvantage here for sputn since this always
+    // results in a call to xsputn.
+
+    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
+    {
+      if (!traits_type::eq_int_type(ch, traits_type::eof()))
+        buffer_.push_back(static_cast<Char>(ch));
+      return ch;
+    }
+
+    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
+    {
+      buffer_.append(s, s + count);
+      return count;
+    }
+  };
+
+  template <typename Char> struct test_stream : std::basic_ostream<Char>
+  {
+  private:
+    // Hide all operator<< from std::basic_ostream<Char>.
+    void_t<> operator<<(null<>);
+    void_t<> operator<<(const Char *);
+
+    template <typename T,
+              FMT_ENABLE_IF(std::is_convertible<T, int>::value && !std::is_enum<T>::value)>
+    void_t<> operator<<(T);
+  };
+
+  // Checks if T has a user-defined operator<< (e.g. not a member of
+  // std::ostream).
+  template <typename T, typename Char> class is_streamable
+  {
+  private:
+    template <typename U>
+    static bool_constant<!std::is_same<
+        decltype(std::declval<test_stream<Char> &>() << std::declval<U>()), void_t<>>::value>
+    test(int);
+
+    template <typename> static std::false_type test(...);
+
+    using result = decltype(test<T>(0));
+
+  public:
+    static const bool value = result::value;
+  };
+
+  // Write the content of buf to os.
+  template <typename Char> void write(std::basic_ostream<Char> &os, buffer<Char> &buf)
+  {
+    const Char *buf_data         = buf.data();
+    using unsigned_streamsize    = std::make_unsigned<std::streamsize>::type;
+    unsigned_streamsize size     = buf.size();
+    unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+    do {
+      unsigned_streamsize n = size <= max_size ? size : max_size;
+      os.write(buf_data, static_cast<std::streamsize>(n));
+      buf_data += n;
+      size -= n;
+    } while (size != 0);
   }
 
-  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
+  template <typename Char, typename T> void format_value(buffer<Char> &buf, const T &value)
+  {
+    formatbuf<Char>          format_buf(buf);
+    std::basic_ostream<Char> output(&format_buf);
+    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+    output << value;
+    buf.resize(buf.size());
   }
-};
-
-template <typename Char> struct test_stream : std::basic_ostream<Char> {
- private:
-  struct null;
-  // Hide all operator<< from std::basic_ostream<Char>.
-  void operator<<(null);
-};
-
-// Checks if T has a user-defined operator<< (e.g. not a member of
-// std::ostream).
-template <typename T, typename Char> class is_streamable {
- private:
-  template <typename U>
-  static decltype((void)(std::declval<test_stream<Char>&>()
-                         << std::declval<U>()),
-                  std::true_type())
-  test(int);
-
-  template <typename> static std::false_type test(...);
-
-  using result = decltype(test<T>(0));
-
- public:
-  static const bool value = result::value;
-};
-
-// Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char>& os, buffer<Char>& buf) {
-  const Char* buf_data = buf.data();
-  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
-  unsigned_streamsize size = buf.size();
-  unsigned_streamsize max_size =
-      to_unsigned((std::numeric_limits<std::streamsize>::max)());
-  do {
-    unsigned_streamsize n = size <= max_size ? size : max_size;
-    os.write(buf_data, static_cast<std::streamsize>(n));
-    buf_data += n;
-    size -= n;
-  } while (size != 0);
-}
 
-template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value) {
-  formatbuf<Char> format_buf(buf);
-  std::basic_ostream<Char> output(&format_buf);
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  output << value;
-  buf.resize(buf.size());
-}
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
-    : formatter<basic_string_view<Char>, Char> {
-  template <typename Context>
-  auto format(const T& value, Context& ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buffer;
-    format_value(buffer, value);
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-  }
-};
-}  // namespace internal
+  // Formats an object of type T that has an overloaded ostream operator<<.
+  template <typename T, typename Char>
+  struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+      : formatter<basic_string_view<Char>, Char>
+  {
+    template <typename Context> auto format(const T &value, Context &ctx) -> decltype(ctx.out())
+    {
+      basic_memory_buffer<Char> buffer;
+      format_value(buffer, value);
+      basic_string_view<Char> str(buffer.data(), buffer.size());
+      return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+    }
+  };
+} // namespace internal
 
 template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
-            basic_format_args<buffer_context<Char>> args) {
+void vprint(std::basic_ostream<Char> &os, basic_string_view<Char> format_str,
+            basic_format_args<buffer_context<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   internal::write(os, buffer);
@@ -127,10 +136,11 @@ void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
  */
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+void print(std::basic_ostream<Char> &os, const S &format_str, Args &&... args)
+{
   vprint(os, to_string_view(format_str),
          {internal::make_args_checked<Args...>(format_str, args...)});
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_OSTREAM_H_
+#endif // FMT_OSTREAM_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/printf.h b/packages/seacas/libraries/ioss/src/fmt/printf.h
index c3c330405ef3..9fd493855764 100644
--- a/packages/seacas/libraries/ioss/src/fmt/printf.h
+++ b/packages/seacas/libraries/ioss/src/fmt/printf.h
@@ -8,188 +8,202 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#include <algorithm>  // std::fill_n
-#include <limits>     // std::numeric_limits
+#include <algorithm> // std::fill_n
+#include <limits>    // std::numeric_limits
 
 #include "ostream.h"
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T> inline T const_check(T value) { return value; }
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned> struct int_checker {
-  template <typename T> static bool fits_in_int(T value) {
-    unsigned max = std::numeric_limits<int>::max();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
-};
-
-template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
-    return value >= std::numeric_limits<int>::min() &&
-           value <= std::numeric_limits<int>::max();
-  }
-  static bool fits_in_int(int) { return true; }
-};
-
-class printf_precision_handler {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
-    return (std::max)(static_cast<int>(value), 0);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  int operator()(T) {
-    FMT_THROW(format_error("precision is not integer"));
-    return 0;
-  }
-};
+  // Checks if a value fits in int - used to avoid warnings about comparing
+  // signed and unsigned integers.
+  template <bool IsSigned> struct int_checker
+  {
+    template <typename T> static bool fits_in_int(T value)
+    {
+      unsigned max = max_value<int>();
+      return value <= max;
+    }
+    static bool fits_in_int(bool) { return true; }
+  };
+
+  template <> struct int_checker<true>
+  {
+    template <typename T> static bool fits_in_int(T value)
+    {
+      return value >= std::numeric_limits<int>::min() && value <= max_value<int>();
+    }
+    static bool fits_in_int(int) { return true; }
+  };
+
+  class printf_precision_handler
+  {
+  public:
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> int operator()(T value)
+    {
+      if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+        FMT_THROW(format_error("number is too big"));
+      return (std::max)(static_cast<int>(value), 0);
+    }
 
-// An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
-    return value == 0;
-  }
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> int operator()(T)
+    {
+      FMT_THROW(format_error("precision is not integer"));
+      return 0;
+    }
+  };
+
+  // An argument visitor that returns true iff arg is a zero integer.
+  class is_zero_int
+  {
+  public:
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> bool operator()(T value)
+    {
+      return value == 0;
+    }
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
-    return false;
-  }
-};
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> bool operator()(T)
+    {
+      return false;
+    }
+  };
 
-template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
+  template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T>
+  {
+  };
 
-template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+  template <> struct make_unsigned_or_bool<bool>
+  {
+    using type = bool;
+  };
 
-template <typename T, typename Context> class arg_converter {
- private:
-  using char_type = typename Context::char_type;
+  template <typename T, typename Context> class arg_converter
+  {
+  private:
+    using char_type = typename Context::char_type;
 
-  basic_format_arg<Context>& arg_;
-  char_type type_;
+    basic_format_arg<Context> &arg_;
+    char_type                  type_;
 
- public:
-  arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
+  public:
+    arg_converter(basic_format_arg<Context> &arg, char_type type) : arg_(arg), type_(type) {}
 
-  void operator()(bool value) {
-    if (type_ != 's') operator()<bool>(value);
-  }
+    void operator()(bool value)
+    {
+      if (type_ != 's')
+        operator()<bool>(value);
+    }
 
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
-    if (const_check(sizeof(target_type) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-            static_cast<int>(static_cast<target_type>(value)));
-      } else {
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        arg_ = internal::make_arg<Context>(
-            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+    template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)> void operator()(U value)
+    {
+      bool is_signed    = type_ == 'd' || type_ == 'i';
+      using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+      if (const_check(sizeof(target_type) <= sizeof(int))) {
+        // Extra casts are used to silence warnings.
+        if (is_signed) {
+          arg_ = internal::make_arg<Context>(static_cast<int>(static_cast<target_type>(value)));
+        }
+        else {
+          using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+          arg_ =
+              internal::make_arg<Context>(static_cast<unsigned>(static_cast<unsigned_type>(value)));
+        }
       }
-    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
-      } else {
-        arg_ = internal::make_arg<Context>(
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      else {
+        if (is_signed) {
+          // glibc's printf doesn't sign extend arguments of smaller types:
+          //   std::printf("%lld", -42);  // prints "4294967254"
+          // but we don't have to do the same because it's a UB.
+          arg_ = internal::make_arg<Context>(static_cast<long long>(value));
+        }
+        else {
+          arg_ = internal::make_arg<Context>(
+              static_cast<typename make_unsigned_or_bool<U>::type>(value));
+        }
       }
     }
-  }
 
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
-};
+    template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+    void operator()(U) {} // No conversion needed for non-integral types.
+  };
+
+  // Converts an integer argument to T for printf, if T is an integral type.
+  // If T is void, the argument is converted to corresponding signed or unsigned
+  // type depending on the type specifier: 'd' and 'i' - signed, other -
+  // unsigned).
+  template <typename T, typename Context, typename Char>
+  void convert_arg(basic_format_arg<Context> &arg, Char type)
+  {
+    visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+  }
 
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
-}
+  // Converts an integer argument to char for printf.
+  template <typename Context> class char_converter
+  {
+  private:
+    basic_format_arg<Context> &arg_;
 
-// Converts an integer argument to char for printf.
-template <typename Context> class char_converter {
- private:
-  basic_format_arg<Context>& arg_;
+  public:
+    explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
 
- public:
-  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> void operator()(T value)
+    {
+      arg_ = internal::make_arg<Context>(static_cast<typename Context::char_type>(value));
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  void operator()(T value) {
-    arg_ = internal::make_arg<Context>(
-        static_cast<typename Context::char_type>(value));
-  }
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+    void operator()(T) {} // No conversion needed for non-integral types.
+  };
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  void operator()(T) {}  // No conversion needed for non-integral types.
-};
+  // Checks if an argument is a valid printf width specifier and sets
+  // left alignment if it is negative.
+  template <typename Char> class printf_width_handler
+  {
+  private:
+    using format_specs = basic_format_specs<Char>;
 
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-template <typename Char> class printf_width_handler {
- private:
-  using format_specs = basic_format_specs<Char>;
+    format_specs &specs_;
 
-  format_specs& specs_;
+  public:
+    explicit printf_width_handler(format_specs &specs) : specs_(specs) {}
 
- public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> unsigned operator()(T value)
+    {
+      auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+      if (internal::is_negative(value)) {
+        specs_.align = align::left;
+        width        = 0 - width;
+      }
+      unsigned int_max = max_value<int>();
+      if (width > int_max)
+        FMT_THROW(format_error("number is too big"));
+      return static_cast<unsigned>(width);
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(T value) {
-    auto width = static_cast<uint32_or_64_t<T>>(value);
-    if (internal::is_negative(value)) {
-      specs_.align = align::left;
-      width = 0 - width;
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> unsigned operator()(T)
+    {
+      FMT_THROW(format_error("width is not integer"));
+      return 0;
     }
-    unsigned int_max = std::numeric_limits<int>::max();
-    if (width > int_max) FMT_THROW(format_error("number is too big"));
-    return static_cast<unsigned>(width);
-  }
+  };
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  unsigned operator()(T) {
-    FMT_THROW(format_error("width is not integer"));
-    return 0;
+  template <typename Char, typename Context>
+  void printf(buffer<Char> &buf, basic_string_view<Char> format, basic_format_args<Context> args)
+  {
+    Context(std::back_inserter(buf), format, args).format();
   }
-};
-
-template <typename Char, typename Context>
-void printf(buffer<Char>& buf, basic_string_view<Char> format,
-            basic_format_args<Context> args) {
-  Context(std::back_inserter(buf), format, args).format();
-}
 
-template <typename OutputIt, typename Char, typename Context>
-internal::truncating_iterator<OutputIt> printf(
-    internal::truncating_iterator<OutputIt> it, basic_string_view<Char> format,
-    basic_format_args<Context> args) {
-  return Context(it, format, args).format();
-}
-}  // namespace internal
+  template <typename OutputIt, typename Char, typename Context>
+  internal::truncating_iterator<OutputIt> printf(internal::truncating_iterator<OutputIt> it,
+                                                 basic_string_view<Char>                 format,
+                                                 basic_format_args<Context>              args)
+  {
+    return Context(it, format, args).format();
+  }
+} // namespace internal
 
-using internal::printf;  // For printing into memory_buffer.
+using internal::printf; // For printing into memory_buffer.
 
 template <typename Range> class printf_arg_formatter;
 
@@ -200,29 +214,31 @@ template <typename OutputIt, typename Char> class basic_printf_context;
   The ``printf`` argument formatter.
   \endrst
  */
-template <typename Range>
-class printf_arg_formatter : public internal::arg_formatter_base<Range> {
- public:
+template <typename Range> class printf_arg_formatter : public internal::arg_formatter_base<Range>
+{
+public:
   using iterator = typename Range::iterator;
 
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
+private:
+  using char_type    = typename Range::value_type;
+  using base         = internal::arg_formatter_base<Range>;
   using context_type = basic_printf_context<iterator, char_type>;
 
-  context_type& context_;
+  context_type &context_;
 
-  void write_null_pointer(char) {
+  void write_null_pointer(char)
+  {
     this->specs()->type = 0;
     this->write("(nil)");
   }
 
-  void write_null_pointer(wchar_t) {
+  void write_null_pointer(wchar_t)
+  {
     this->specs()->type = 0;
     this->write(L"(nil)");
   }
 
- public:
+public:
   using format_specs = typename base::format_specs;
 
   /**
@@ -232,39 +248,47 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
     specifier information for standard argument types.
     \endrst
    */
-  printf_arg_formatter(iterator iter, format_specs& my_specs, context_type& ctx)
-      : base(Range(iter), &my_specs, internal::locale_ref()), context_(ctx) {}
+  printf_arg_formatter(iterator iter, format_specs &specs, context_type &ctx)
+      : base(Range(iter), &specs, internal::locale_ref()), context_(ctx)
+  {
+  }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  iterator operator()(T value) {
+  template <typename T, FMT_ENABLE_IF(fmt::internal::is_integral<T>::value)>
+  iterator operator()(T value)
+  {
     // MSVC2013 fails to compile separate overloads for bool and char_type so
     // use std::is_same instead.
     if (std::is_same<T, bool>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
+      format_specs &fmt_specs = *this->specs();
+      if (fmt_specs.type != 's')
+        return base::operator()(value ? 1 : 0);
       fmt_specs.type = 0;
       this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs& fmt_specs = *this->specs();
+    }
+    else if (std::is_same<T, char_type>::value) {
+      format_specs &fmt_specs = *this->specs();
       if (fmt_specs.type && fmt_specs.type != 'c')
         return (*this)(static_cast<int>(value));
-      fmt_specs.sign = sign::none;
-      fmt_specs.alt = false;
+      fmt_specs.sign  = sign::none;
+      fmt_specs.alt   = false;
       fmt_specs.align = align::right;
       return base::operator()(value);
-    } else {
+    }
+    else {
       return base::operator()(value);
     }
     return this->out();
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
+  iterator operator()(T value)
+  {
     return base::operator()(value);
   }
 
   /** Formats a null-terminated C string. */
-  iterator operator()(const char* value) {
+  iterator operator()(const char *value)
+  {
     if (value)
       base::operator()(value);
     else if (this->specs()->type == 'p')
@@ -275,7 +299,8 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
   }
 
   /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t* value) {
+  iterator operator()(const wchar_t *value)
+  {
     if (value)
       base::operator()(value);
     else if (this->specs()->type == 'p')
@@ -285,66 +310,69 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
     return this->out();
   }
 
-  iterator operator()(basic_string_view<char_type> value) {
-    return base::operator()(value);
-  }
+  iterator operator()(basic_string_view<char_type> value) { return base::operator()(value); }
 
   iterator operator()(monostate value) { return base::operator()(value); }
 
   /** Formats a pointer. */
-  iterator operator()(const void* value) {
-    if (value) return base::operator()(value);
+  iterator operator()(const void *value)
+  {
+    if (value)
+      return base::operator()(value);
     this->specs()->type = 0;
     write_null_pointer(char_type());
     return this->out();
   }
 
   /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+  iterator operator()(typename basic_format_arg<context_type>::handle handle)
+  {
     handle.format(context_.parse_context(), context_);
     return this->out();
   }
 };
 
-template <typename T> struct printf_formatter {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+template <typename T> struct printf_formatter
+{
+  template <typename ParseContext> auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return ctx.begin();
   }
 
   template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out())
+  {
     internal::format_value(internal::get_container(ctx.out()), value);
     return ctx.out();
   }
 };
 
 /** This template formats data and writes the output to a writer. */
-template <typename OutputIt, typename Char> class basic_printf_context {
- public:
+template <typename OutputIt, typename Char> class basic_printf_context
+{
+public:
   /** The character type for the output. */
-  using char_type = Char;
-  using format_arg = basic_format_arg<basic_printf_context>;
+  using char_type                            = Char;
+  using format_arg                           = basic_format_arg<basic_printf_context>;
   template <typename T> using formatter_type = printf_formatter<T>;
 
- private:
+private:
   using format_specs = basic_format_specs<char_type>;
 
-  OutputIt out_;
+  OutputIt                                out_;
   basic_format_args<basic_printf_context> args_;
-  basic_parse_context<Char> parse_ctx_;
+  basic_parse_context<Char>               parse_ctx_;
 
-  static void parse_flags(format_specs& specs, const Char*& it,
-                          const Char* end);
+  static void parse_flags(format_specs &specs, const Char *&it, const Char *end);
 
   // Returns the argument with specified index or, if arg_index is equal
   // to the maximum unsigned value, the next argument.
-  format_arg get_arg(unsigned arg_index = std::numeric_limits<unsigned>::max());
+  format_arg get_arg(unsigned arg_index = internal::max_value<unsigned>());
 
   // Parses argument index, flags and width and returns the argument index.
-  unsigned parse_header(const Char*& it, const Char* end, format_specs& specs);
+  unsigned parse_header(const Char *&it, const Char *end, format_specs &specs);
 
- public:
+public:
   /**
    \rst
    Constructs a ``printf_context`` object. References to the arguments and
@@ -352,58 +380,46 @@ template <typename OutputIt, typename Char> class basic_printf_context {
    appropriate lifetimes.
    \endrst
    */
-  basic_printf_context(OutputIt it_out, basic_string_view<char_type> format_str,
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
                        basic_format_args<basic_printf_context> args)
-      : out_(it_out), args_(args), parse_ctx_(format_str) {}
+      : out_(out), args_(args), parse_ctx_(format_str)
+  {
+  }
 
   OutputIt out() { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
+  void     advance_to(OutputIt it) { out_ = it; }
 
   format_arg arg(unsigned id) const { return args_.get(id); }
 
-  basic_parse_context<Char>& parse_context() { return parse_ctx_; }
+  basic_parse_context<Char> &parse_context() { return parse_ctx_; }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    parse_ctx_.on_error(message);
-  }
+  FMT_CONSTEXPR void on_error(const char *message) { parse_ctx_.on_error(message); }
 
   /** Formats stored arguments and writes the output to the range. */
-  template <typename ArgFormatter =
-                printf_arg_formatter<internal::buffer_range<Char>>>
-  OutputIt format();
+  template <typename ArgFormatter = printf_arg_formatter<buffer_range<Char>>> OutputIt format();
 };
 
 template <typename OutputIt, typename Char>
-void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
-                                                       const Char*& it,
-                                                       const Char* end) {
+void basic_printf_context<OutputIt, Char>::parse_flags(format_specs &specs, const Char *&it,
+                                                       const Char *end)
+{
   for (; it != end; ++it) {
     switch (*it) {
-    case '-':
-      specs.align = align::left;
-      break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill[0] = '0';
-      break;
-    case ' ':
-      specs.sign = sign::space;
-      break;
-    case '#':
-      specs.alt = true;
-      break;
-    default:
-      return;
+    case '-': specs.align = align::left; break;
+    case '+': specs.sign = sign::plus; break;
+    case '0': specs.fill[0] = '0'; break;
+    case ' ': specs.sign = sign::space; break;
+    case '#': specs.alt = true; break;
+    default: return;
     }
   }
 }
 
 template <typename OutputIt, typename Char>
 typename basic_printf_context<OutputIt, Char>::format_arg
-basic_printf_context<OutputIt, Char>::get_arg(unsigned arg_index) {
-  if (arg_index == std::numeric_limits<unsigned>::max())
+basic_printf_context<OutputIt, Char>::get_arg(unsigned arg_index)
+{
+  if (arg_index == internal::max_value<unsigned>())
     arg_index = parse_ctx_.next_arg_id();
   else
     parse_ctx_.check_arg_id(--arg_index);
@@ -411,20 +427,23 @@ basic_printf_context<OutputIt, Char>::get_arg(unsigned arg_index) {
 }
 
 template <typename OutputIt, typename Char>
-unsigned basic_printf_context<OutputIt, Char>::parse_header(
-    const Char*& it, const Char* end, format_specs& specs) {
-  unsigned arg_index = std::numeric_limits<unsigned>::max();
-  char_type c = *it;
+unsigned basic_printf_context<OutputIt, Char>::parse_header(const Char *&it, const Char *end,
+                                                            format_specs &specs)
+{
+  unsigned  arg_index = internal::max_value<unsigned>();
+  char_type c         = *it;
   if (c >= '0' && c <= '9') {
     // Parse an argument index (if followed by '$') or a width possibly
     // preceded with '0' flag(s).
     internal::error_handler eh;
-    unsigned value = parse_nonnegative_int(it, end, eh);
-    if (it != end && *it == '$') {  // value is an argument index
+    unsigned                value = parse_nonnegative_int(it, end, eh);
+    if (it != end && *it == '$') { // value is an argument index
       ++it;
       arg_index = value;
-    } else {
-      if (c == '0') specs.fill[0] = '0';
+    }
+    else {
+      if (c == '0')
+        specs.fill[0] = '0';
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
@@ -439,10 +458,10 @@ unsigned basic_printf_context<OutputIt, Char>::parse_header(
     if (*it >= '0' && *it <= '9') {
       internal::error_handler eh;
       specs.width = parse_nonnegative_int(it, end, eh);
-    } else if (*it == '*') {
+    }
+    else if (*it == '*') {
       ++it;
-      specs.width = visit_format_arg(
-          internal::printf_width_handler<char_type>(specs), get_arg());
+      specs.width = visit_format_arg(internal::printf_width_handler<char_type>(specs), get_arg());
     }
   }
   return arg_index;
@@ -450,26 +469,30 @@ unsigned basic_printf_context<OutputIt, Char>::parse_header(
 
 template <typename OutputIt, typename Char>
 template <typename ArgFormatter>
-OutputIt basic_printf_context<OutputIt, Char>::format() {
-  auto my_out = this->out();
-  const Char* start = parse_ctx_.begin();
-  const Char* end = parse_ctx_.end();
-  auto it = start;
+OutputIt basic_printf_context<OutputIt, Char>::format()
+{
+  auto        out   = this->out();
+  const Char *start = parse_ctx_.begin();
+  const Char *end   = parse_ctx_.end();
+  auto        it    = start;
   while (it != end) {
     char_type c = *it++;
-    if (c != '%') continue;
+    if (c != '%')
+      continue;
     if (it != end && *it == c) {
-      my_out = std::copy(start, it, my_out);
+      out   = std::copy(start, it, out);
       start = ++it;
       continue;
     }
-    my_out = std::copy(start, it - 1, my_out);
+    out = std::copy(start, it - 1, out);
 
     format_specs specs;
     specs.align = align::right;
 
     // Parse argument index, flags and width.
     unsigned arg_index = parse_header(it, end, specs);
+    if (arg_index == 0)
+      on_error("argument index out of range");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -478,27 +501,28 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       if ('0' <= c && c <= '9') {
         internal::error_handler eh;
         specs.precision = static_cast<int>(parse_nonnegative_int(it, end, eh));
-      } else if (c == '*') {
+      }
+      else if (c == '*') {
         ++it;
-        specs.precision =
-            visit_format_arg(internal::printf_precision_handler(), get_arg());
-      } else {
+        specs.precision = visit_format_arg(internal::printf_precision_handler(), get_arg());
+      }
+      else {
         specs.precision = 0;
       }
     }
 
-    format_arg my_arg = get_arg(arg_index);
-    if (specs.alt && visit_format_arg(internal::is_zero_int(), my_arg))
+    format_arg arg = get_arg(arg_index);
+    if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
       specs.alt = false;
     if (specs.fill[0] == '0') {
-      if (my_arg.is_arithmetic())
+      if (arg.is_arithmetic())
         specs.align = align::numeric;
       else
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types.
+        specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types.
     }
 
     // Parse length and convert the argument to the required type.
-    c = it != end ? *it++ : 0;
+    c           = it != end ? *it++ : 0;
     char_type t = it != end ? *it : 0;
     using internal::convert_arg;
     switch (c) {
@@ -506,72 +530,61 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       if (t == 'h') {
         ++it;
         t = it != end ? *it : 0;
-        convert_arg<signed char>(my_arg, t);
-      } else {
-        convert_arg<short>(my_arg, t);
+        convert_arg<signed char>(arg, t);
+      }
+      else {
+        convert_arg<short>(arg, t);
       }
       break;
     case 'l':
       if (t == 'l') {
         ++it;
         t = it != end ? *it : 0;
-        convert_arg<long long>(my_arg, t);
-      } else {
-        convert_arg<long>(my_arg, t);
+        convert_arg<long long>(arg, t);
+      }
+      else {
+        convert_arg<long>(arg, t);
       }
       break;
-    case 'j':
-      convert_arg<intmax_t>(my_arg, t);
-      break;
-    case 'z':
-      convert_arg<std::size_t>(my_arg, t);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(my_arg, t);
-      break;
+    case 'j': convert_arg<intmax_t>(arg, t); break;
+    case 'z': convert_arg<std::size_t>(arg, t); break;
+    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
     case 'L':
       // printf produces garbage when 'L' is omitted for long double, no
       // need to do the same.
       break;
-    default:
-      --it;
-      convert_arg<void>(my_arg, c);
+    default: --it; convert_arg<void>(arg, c);
     }
 
     // Parse type.
-    if (it == end) FMT_THROW(format_error("invalid format string"));
+    if (it == end)
+      FMT_THROW(format_error("invalid format string"));
     specs.type = static_cast<char>(*it++);
-    if (my_arg.is_integral()) {
+    if (arg.is_integral()) {
       // Normalize type.
       switch (specs.type) {
       case 'i':
-      case 'u':
-        specs.type = 'd';
-        break;
-      case 'c':
-        visit_format_arg(internal::char_converter<basic_printf_context>(my_arg),
-                         my_arg);
-        break;
+      case 'u': specs.type = 'd'; break;
+      case 'c': visit_format_arg(internal::char_converter<basic_printf_context>(arg), arg); break;
       }
     }
 
     start = it;
 
     // Format argument.
-    visit_format_arg(ArgFormatter(my_out, specs, *this), my_arg);
+    visit_format_arg(ArgFormatter(out, specs, *this), arg);
   }
-  return std::copy(start, it, my_out);
+  return std::copy(start, it, out);
 }
 
 template <typename Char>
 using basic_printf_context_t =
-    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>,
-                         Char>;
+    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>, Char>;
 
-using printf_context = basic_printf_context_t<char>;
+using printf_context  = basic_printf_context_t<char>;
 using wprintf_context = basic_printf_context_t<wchar_t>;
 
-using printf_args = basic_format_args<printf_context>;
+using printf_args  = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;
 
 /**
@@ -581,8 +594,8 @@ using wprintf_args = basic_format_args<wprintf_context>;
   \endrst
  */
 template <typename... Args>
-inline format_arg_store<printf_context, Args...> make_printf_args(
-    const Args&... args) {
+inline format_arg_store<printf_context, Args...> make_printf_args(const Args &... args)
+{
   return {args...};
 }
 
@@ -593,14 +606,15 @@ inline format_arg_store<printf_context, Args...> make_printf_args(
   \endrst
  */
 template <typename... Args>
-inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
-    const Args&... args) {
+inline format_arg_store<wprintf_context, Args...> make_wprintf_args(const Args &... args)
+{
   return {args...};
 }
 
 template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vsprintf(
-    const S& format, basic_format_args<basic_printf_context_t<Char>> args) {
+inline std::basic_string<Char> vsprintf(const S &                                       format,
+                                        basic_format_args<basic_printf_context_t<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   return to_string(buffer);
@@ -617,20 +631,20 @@ inline std::basic_string<Char> vsprintf(
 */
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
+inline std::basic_string<Char> sprintf(const S &format, const Args &... args)
+{
   using context = basic_printf_context_t<Char>;
   return vsprintf(to_string_view(format), {make_format_args<context>(args...)});
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::FILE* f, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
+inline int vfprintf(std::FILE *f, const S &format,
+                    basic_format_args<basic_printf_context_t<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   std::size_t size = buffer.size();
-  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
-             ? -1
-             : static_cast<int>(size);
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
 }
 
 /**
@@ -644,15 +658,15 @@ inline int vfprintf(std::FILE* f, const S& format,
  */
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
+inline int fprintf(std::FILE *f, const S &format, const Args &... args)
+{
   using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(format),
-                  {make_format_args<context>(args...)});
+  return vfprintf(f, to_string_view(format), {make_format_args<context>(args...)});
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vprintf(const S& format,
-                   basic_format_args<basic_printf_context_t<Char>> args) {
+inline int vprintf(const S &format, basic_format_args<basic_printf_context_t<Char>> args)
+{
   return vfprintf(stdout, to_string_view(format), args);
 }
 
@@ -665,17 +679,17 @@ inline int vprintf(const S& format,
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline int printf(const S& format_str, const Args&... args) {
+template <typename S, typename... Args, FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline int printf(const S &format_str, const Args &... args)
+{
   using context = basic_printf_context_t<char_t<S>>;
-  return vprintf(to_string_view(format_str),
-                 {make_format_args<context>(args...)});
+  return vprintf(to_string_view(format_str), {make_format_args<context>(args...)});
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::basic_ostream<Char>& os, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
+inline int vfprintf(std::basic_ostream<Char> &os, const S &format,
+                    basic_format_args<basic_printf_context_t<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   internal::write(os, buffer);
@@ -684,11 +698,11 @@ inline int vfprintf(std::basic_ostream<Char>& os, const S& format,
 
 /** Formats arguments and writes the output to the range. */
 template <typename ArgFormatter, typename Char,
-          typename Context =
-              basic_printf_context<typename ArgFormatter::iterator, Char>>
-typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
-                                        basic_string_view<Char> format_str,
-                                        basic_format_args<Context> args) {
+          typename Context = basic_printf_context<typename ArgFormatter::iterator, Char>>
+typename ArgFormatter::iterator vprintf(internal::buffer<Char> &   out,
+                                        basic_string_view<Char>    format_str,
+                                        basic_format_args<Context> args)
+{
   typename ArgFormatter::iterator iter(out);
   Context(iter, format_str, args).template format<ArgFormatter>();
   return iter;
@@ -704,12 +718,11 @@ typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
   \endrst
  */
 template <typename S, typename... Args, typename Char = char_t<S>>
-inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
-                   const Args&... args) {
+inline int fprintf(std::basic_ostream<Char> &os, const S &format_str, const Args &... args)
+{
   using context = basic_printf_context_t<Char>;
-  return vfprintf(os, to_string_view(format_str),
-                  {make_format_args<context>(args...)});
+  return vfprintf(os, to_string_view(format_str), {make_format_args<context>(args...)});
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_PRINTF_H_
+#endif // FMT_PRINTF_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/ranges.h b/packages/seacas/libraries/ioss/src/fmt/ranges.h
index cf0d41aaa5ee..6325f642d3d3 100644
--- a/packages/seacas/libraries/ioss/src/fmt/ranges.h
+++ b/packages/seacas/libraries/ioss/src/fmt/ranges.h
@@ -12,28 +12,30 @@
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
 
-#include <type_traits>
 #include "format.h"
+#include <type_traits>
 
 // output only up to N items from the range.
 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-#  define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
 #endif
 
 FMT_BEGIN_NAMESPACE
 
-template <typename Char> struct formatting_base {
+template <typename Char> struct formatting_base
+{
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return ctx.begin();
   }
 };
 
-template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char> {
+template <typename Char, typename Enable = void> struct formatting_range : formatting_base<Char>
+{
   static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
-                                      // range.
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the
+                                     // range.
   Char prefix;
   Char delimiter;
   Char postfix;
@@ -42,8 +44,8 @@ struct formatting_range : formatting_base<Char> {
   static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
-template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char> {
+template <typename Char, typename Enable = void> struct formatting_tuple : formatting_base<Char>
+{
   Char prefix;
   Char delimiter;
   Char postfix;
@@ -54,182 +56,199 @@ struct formatting_tuple : formatting_base<Char> {
 
 namespace internal {
 
-template <typename RangeT, typename OutputIterator>
-OutputIterator copy(const RangeT& range, OutputIterator out) {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
-  return out;
-}
+  template <typename RangeT, typename OutputIterator>
+  OutputIterator copy(const RangeT &range, OutputIterator out)
+  {
+    for (auto it = range.begin(), end = range.end(); it != end; ++it)
+      *out++ = *it;
+    return out;
+  }
 
-template <typename OutputIterator>
-OutputIterator copy(const char* str, OutputIterator out) {
-  while (*str) *out++ = *str++;
-  return out;
-}
+  template <typename OutputIterator> OutputIterator copy(const char *str, OutputIterator out)
+  {
+    while (*str)
+      *out++ = *str++;
+    return out;
+  }
 
-template <typename OutputIterator>
-OutputIterator copy(char ch, OutputIterator out) {
-  *out++ = ch;
-  return out;
-}
+  template <typename OutputIterator> OutputIterator copy(char ch, OutputIterator out)
+  {
+    *out++ = ch;
+    return out;
+  }
 
-/// Return true value if T has std::string interface, like std::string_view.
-template <typename T> class is_like_std_string {
-  template <typename U>
-  static auto check(U* p)
-      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
-  template <typename> static void check(...);
+  /// Return true value if T has std::string interface, like std::string_view.
+  template <typename T> class is_like_std_string
+  {
+    template <typename U>
+    static auto check(U *p) -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+    template <typename> static void check(...);
 
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
-};
+  public:
+    static FMT_CONSTEXPR_DECL const bool value =
+        is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+  };
 
-template <typename Char>
-struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
+  template <typename Char> struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type
+  {
+  };
 
-template <typename... Ts> struct conditional_helper {};
+  template <typename... Ts> struct conditional_helper
+  {
+  };
 
-template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+  template <typename T, typename _ = void> struct is_range_ : std::false_type
+  {
+  };
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
-template <typename T>
-struct is_range_<
-    T, conditional_t<false,
-                     conditional_helper<decltype(std::declval<T>().begin()),
-                                        decltype(std::declval<T>().end())>,
-                     void>> : std::true_type {};
+  template <typename T>
+  struct is_range_<T, conditional_t<false,
+                                    conditional_helper<decltype(std::declval<T>().begin()),
+                                                       decltype(std::declval<T>().end())>,
+                                    void>> : std::true_type
+  {
+  };
 #endif
 
-/// tuple_size and tuple_element check.
-template <typename T> class is_tuple_like_ {
-  template <typename U>
-  static auto check(U* p)
-      -> decltype(std::tuple_size<U>::value,
-                  (void)std::declval<typename std::tuple_element<0, U>::type>(),
-                  int());
-  template <typename> static void check(...);
-
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
+  /// tuple_size and tuple_element check.
+  template <typename T> class is_tuple_like_
+  {
+    template <typename U>
+    static auto check(U *p)
+        -> decltype(std::tuple_size<U>::value,
+                    (void)std::declval<typename std::tuple_element<0, U>::type>(), int());
+    template <typename> static void check(...);
+
+  public:
+    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
+  };
 
 // Check for integer_sequence
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template <typename T, T... N>
-using integer_sequence = std::integer_sequence<T, N...>;
-template <std::size_t... N> using index_sequence = std::index_sequence<N...>;
-template <std::size_t N>
-using make_index_sequence = std::make_index_sequence<N>;
+  template <typename T, T... N> using integer_sequence = std::integer_sequence<T, N...>;
+  template <std::size_t... N> using index_sequence     = std::index_sequence<N...>;
+  template <std::size_t N> using make_index_sequence   = std::make_index_sequence<N>;
 #else
-template <typename T, T... N> struct integer_sequence {
-  using value_type = T;
+  template <typename T, T... N> struct integer_sequence
+  {
+    using value_type = T;
 
-  static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
-};
+    static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
+  };
 
-template <std::size_t... N>
-using index_sequence = integer_sequence<std::size_t, N...>;
+  template <std::size_t... N> using index_sequence = integer_sequence<std::size_t, N...>;
 
-template <typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-template <typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+  template <typename T, std::size_t N, T... Ns>
+  struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
+  {
+  };
+  template <typename T, T... Ns>
+  struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
+  {
+  };
 
-template <std::size_t N>
-using make_index_sequence = make_integer_sequence<std::size_t, N>;
+  template <std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;
 #endif
 
-template <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
-  using std::get;
-  // using free function get<I>(T) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  (void)_;  // blocks warnings
-}
+  template <class Tuple, class F, size_t... Is>
+  void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT
+  {
+    using std::get;
+    // using free function get<I>(T) now.
+    const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+    (void)_; // blocks warnings
+  }
 
-template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
-    T const&) {
-  return {};
-}
+  template <class T>
+  FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
+  {
+    return {};
+  }
 
-template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
-  const auto indexes = get_indexes(tup);
-  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
-}
+  template <class Tuple, class F> void for_each(Tuple &&tup, F &&f)
+  {
+    const auto indexes = get_indexes(tup);
+    for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+  }
 
-template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<
-                                      typename std::decay<Arg>::type>::value)>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
-  return add_space ? " {}" : "{}";
-}
+  template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<typename std::decay<Arg>::type>::value)>
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const Arg &)
+  {
+    return add_space ? " {}" : "{}";
+  }
 
-template <typename Arg, FMT_ENABLE_IF(is_like_std_string<
-                                      typename std::decay<Arg>::type>::value)>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
+  template <typename Arg, FMT_ENABLE_IF(is_like_std_string<typename std::decay<Arg>::type>::value)>
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const Arg &)
+  {
+    return add_space ? " \"{}\"" : "\"{}\"";
+  }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
-  return add_space ? L" \"{}\"" : L"\"{}\"";
-}
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *)
+  {
+    return add_space ? " \"{}\"" : "\"{}\"";
+  }
+  FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *)
+  {
+    return add_space ? L" \"{}\"" : L"\"{}\"";
+  }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
-  return add_space ? " '{}'" : "'{}'";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
-  return add_space ? L" '{}'" : L"'{}'";
-}
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char)
+  {
+    return add_space ? " '{}'" : "'{}'";
+  }
+  FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t)
+  {
+    return add_space ? L" '{}'" : L"'{}'";
+  }
 
-}  // namespace internal
+} // namespace internal
 
-template <typename T> struct is_tuple_like {
+template <typename T> struct is_tuple_like
+{
   static FMT_CONSTEXPR_DECL const bool value =
       internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
 };
 
 template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
- private:
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>>
+{
+private:
   // C++11 generic lambda for format()
-  template <typename FormatContext> struct format_each {
-    template <typename T> void operator()(const T& v) {
+  template <typename FormatContext> struct format_each
+  {
+    template <typename T> void operator()(const T &v)
+    {
       if (i > 0) {
         if (formatting.add_prepostfix_space) {
           *out++ = ' ';
         }
         out = internal::copy(formatting.delimiter, out);
       }
-      out = format_to(out,
-                      internal::format_str_quoted(
-                          (formatting.add_delimiter_spaces && i > 0), v),
-                      v);
+      out = format_to(
+          out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v);
       ++i;
     }
 
-    formatting_tuple<Char>& formatting;
-    std::size_t& i;
-    typename std::add_lvalue_reference<decltype(
-        std::declval<FormatContext>().out())>::type out;
+    formatting_tuple<Char> &formatting;
+    std::size_t &           i;
+    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
   };
 
- public:
+public:
   formatting_tuple<Char> formatting;
 
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return formatting.parse(ctx);
   }
 
   template <typename FormatContext = format_context>
-  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    std::size_t i = 0;
+  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out())
+  {
+    auto        out = ctx.out();
+    std::size_t i   = 0;
     internal::copy(formatting.prefix, out);
 
     internal::for_each(values, format_each<FormatContext>{formatting, i, out});
@@ -242,47 +261,129 @@ struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
   }
 };
 
-template <typename T, typename Char> struct is_range {
+template <typename T, typename Char> struct is_range
+{
   static FMT_CONSTEXPR_DECL const bool value =
-      internal::is_range_<T>::value &&
-      !internal::is_like_std_string<T>::value &&
-      !std::is_convertible<T, std::basic_string<Char>>::value;
+      internal::is_range_<T>::value && !internal::is_like_std_string<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_constructible<internal::std_string_view<Char>, T>::value;
 };
 
 template <typename RangeT, typename Char>
-struct formatter<RangeT, Char,
-                 enable_if_t<fmt::is_range<RangeT, Char>::value>> {
+struct formatter<RangeT, Char, enable_if_t<fmt::is_range<RangeT, Char>::value>>
+{
   formatting_range<Char> formatting;
 
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return formatting.parse(ctx);
   }
 
   template <typename FormatContext>
-  typename FormatContext::iterator format(const RangeT& values,
-                                          FormatContext& ctx) {
-    auto out = internal::copy(formatting.prefix, ctx.out());
-    std::size_t i = 0;
+  typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx)
+  {
+    auto        out = internal::copy(formatting.prefix, ctx.out());
+    std::size_t i   = 0;
     for (auto it = values.begin(), end = values.end(); it != end; ++it) {
       if (i > 0) {
-        if (formatting.add_prepostfix_space) *out++ = ' ';
+        if (formatting.add_prepostfix_space)
+          *out++ = ' ';
         out = internal::copy(formatting.delimiter, out);
       }
-      out = format_to(out,
-                      internal::format_str_quoted(
-                          (formatting.add_delimiter_spaces && i > 0), *it),
-                      *it);
+      out = format_to(
+          out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it);
       if (++i > formatting.range_length_limit) {
         out = format_to(out, " ... <other elements>");
         break;
       }
     }
-    if (formatting.add_prepostfix_space) *out++ = ' ';
+    if (formatting.add_prepostfix_space)
+      *out++ = ' ';
     return internal::copy(formatting.postfix, out);
   }
 };
 
+template <typename Char, typename... T> struct tuple_arg_join : internal::view
+{
+  const std::tuple<T...> &tuple;
+  basic_string_view<Char> sep;
+
+  tuple_arg_join(const std::tuple<T...> &t, basic_string_view<Char> s) : tuple{t}, sep{s} {}
+};
+
+template <typename Char, typename... T> struct formatter<tuple_arg_join<Char, T...>, Char>
+{
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(const tuple_arg_join<Char, T...> &value,
+                                          FormatContext &                   ctx)
+  {
+    return format(value, ctx, internal::make_index_sequence<sizeof...(T)>{});
+  }
+
+private:
+  template <typename FormatContext, size_t... N>
+  typename FormatContext::iterator format(const tuple_arg_join<Char, T...> &value,
+                                          FormatContext &ctx, internal::index_sequence<N...>)
+  {
+    return format_args(value, ctx, std::get<N>(value.tuple)...);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format_args(const tuple_arg_join<Char, T...> &,
+                                               FormatContext &ctx)
+  {
+    // NOTE: for compilers that support C++17, this empty function instantiation
+    // can be replaced with a constexpr branch in the variadic overload.
+    return ctx.out();
+  }
+
+  template <typename FormatContext, typename Arg, typename... Args>
+  typename FormatContext::iterator format_args(const tuple_arg_join<Char, T...> &value,
+                                               FormatContext &ctx, const Arg &arg,
+                                               const Args &... args)
+  {
+    using base = formatter<typename std::decay<Arg>::type, Char>;
+    auto out   = ctx.out();
+    out        = base{}.format(arg, ctx);
+    if (sizeof...(Args) > 0) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return format_args(value, ctx, args...);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<char, T...> join(const std::tuple<T...> &tuple, string_view sep)
+{
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<wchar_t, T...> join(const std::tuple<T...> &tuple, wstring_view sep)
+{
+  return {tuple, sep};
+}
+
 FMT_END_NAMESPACE
 
-#endif  // FMT_RANGES_H_
+#endif // FMT_RANGES_H_
diff --git a/packages/seacas/libraries/ioss/src/fmt/safe-duration-cast.h b/packages/seacas/libraries/ioss/src/fmt/safe-duration-cast.h
index aa036182964f..d97b466b1509 100644
--- a/packages/seacas/libraries/ioss/src/fmt/safe-duration-cast.h
+++ b/packages/seacas/libraries/ioss/src/fmt/safe-duration-cast.h
@@ -20,92 +20,95 @@ FMT_BEGIN_NAMESPACE
 
 namespace safe_duration_cast {
 
-template <typename To, typename From,
-          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
-                        std::numeric_limits<From>::is_signed ==
-                            std::numeric_limits<To>::is_signed)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
-  ec = 0;
-  using F = std::numeric_limits<From>;
-  using T = std::numeric_limits<To>;
-  static_assert(F::is_integer, "From must be integral");
-  static_assert(T::is_integer, "To must be integral");
-
-  // A and B are both signed, or both unsigned.
-  if (F::digits <= T::digits) {
-    // From fits in To without any problem.
-  } else {
-    // From does not always fit in To, resort to a dynamic check.
-    if (from < T::min() || from > T::max()) {
-      // outside range.
-      ec = 1;
-      return {};
-    }
-  }
-  return static_cast<To>(from);
-}
-
-/**
- * converts From to To, without loss. If the dynamic value of from
- * can't be converted to To without loss, ec is set.
- */
-template <typename To, typename From,
-          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
-                        std::numeric_limits<From>::is_signed !=
-                            std::numeric_limits<To>::is_signed)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
-  ec = 0;
-  using F = std::numeric_limits<From>;
-  using T = std::numeric_limits<To>;
-  static_assert(F::is_integer, "From must be integral");
-  static_assert(T::is_integer, "To must be integral");
-
-  if (F::is_signed && !T::is_signed) {
-    // From may be negative, not allowed!
-    if (from < 0) {
-      ec = 1;
-      return {};
-    }
-
-    // From is positive. Can it always fit in To?
+  template <typename To, typename From,
+            FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed ==
+                                                                std::numeric_limits<To>::is_signed)>
+  FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+  {
+    ec      = 0;
+    using F = std::numeric_limits<From>;
+    using T = std::numeric_limits<To>;
+    static_assert(F::is_integer, "From must be integral");
+    static_assert(T::is_integer, "To must be integral");
+
+    // A and B are both signed, or both unsigned.
     if (F::digits <= T::digits) {
-      // yes, From always fits in To.
-    } else {
-      // from may not fit in To, we have to do a dynamic check
-      if (from > static_cast<From>(T::max())) {
+      // From fits in To without any problem.
+    }
+    else {
+      // From does not always fit in To, resort to a dynamic check.
+      if (from < T::min() || from > T::max()) {
+        // outside range.
         ec = 1;
         return {};
       }
     }
+    return static_cast<To>(from);
   }
 
-  if (!F::is_signed && T::is_signed) {
-    // can from be held in To?
-    if (F::digits < T::digits) {
-      // yes, From always fits in To.
-    } else {
-      // from may not fit in To, we have to do a dynamic check
-      if (from > static_cast<From>(T::max())) {
-        // outside range.
+  /**
+   * converts From to To, without loss. If the dynamic value of from
+   * can't be converted to To without loss, ec is set.
+   */
+  template <typename To, typename From,
+            FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed !=
+                                                                std::numeric_limits<To>::is_signed)>
+  FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+  {
+    ec      = 0;
+    using F = std::numeric_limits<From>;
+    using T = std::numeric_limits<To>;
+    static_assert(F::is_integer, "From must be integral");
+    static_assert(T::is_integer, "To must be integral");
+
+    if (F::is_signed && !T::is_signed) {
+      // From may be negative, not allowed!
+      if (fmt::internal::is_negative(from)) {
         ec = 1;
         return {};
       }
+
+      // From is positive. Can it always fit in To?
+      if (F::digits <= T::digits) {
+        // yes, From always fits in To.
+      }
+      else {
+        // from may not fit in To, we have to do a dynamic check
+        if (from > static_cast<From>(T::max())) {
+          ec = 1;
+          return {};
+        }
+      }
+    }
+
+    if (!F::is_signed && T::is_signed) {
+      // can from be held in To?
+      if (F::digits < T::digits) {
+        // yes, From always fits in To.
+      }
+      else {
+        // from may not fit in To, we have to do a dynamic check
+        if (from > static_cast<From>(T::max())) {
+          // outside range.
+          ec = 1;
+          return {};
+        }
+      }
     }
-  }
 
-  // reaching here means all is ok for lossless conversion.
-  return static_cast<To>(from);
+    // reaching here means all is ok for lossless conversion.
+    return static_cast<To>(from);
 
-}  // function
+  } // function
 
-template <typename To, typename From,
-          FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
-  ec = 0;
-  return from;
-}  // function
+  template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)>
+  FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+  {
+    ec = 0;
+    return from;
+  } // function
 
-// clang-format off
+  // clang-format off
 /**
  * converts From to To if possible, otherwise ec is set.
  *
@@ -118,176 +121,174 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
  * subnormal                        | best effort
  * -Inf                             | -Inf
  */
-// clang-format on
-template <typename To, typename From,
-          FMT_ENABLE_IF(!std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
-  ec = 0;
-  using T = std::numeric_limits<To>;
-  static_assert(std::is_floating_point<From>::value, "From must be floating");
-  static_assert(std::is_floating_point<To>::value, "To must be floating");
-
-  // catch the only happy case
-  if (std::isfinite(from)) {
-    if (from >= T::lowest() && from <= T::max()) {
-      return static_cast<To>(from);
+  // clang-format on
+  template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value)>
+  FMT_CONSTEXPR To safe_float_conversion(const From from, int &ec)
+  {
+    ec      = 0;
+    using T = std::numeric_limits<To>;
+    static_assert(std::is_floating_point<From>::value, "From must be floating");
+    static_assert(std::is_floating_point<To>::value, "To must be floating");
+
+    // catch the only happy case
+    if (std::isfinite(from)) {
+      if (from >= T::lowest() && from <= T::max()) {
+        return static_cast<To>(from);
+      }
+      // not within range.
+      ec = 1;
+      return {};
     }
-    // not within range.
-    ec = 1;
-    return {};
-  }
 
-  // nan and inf will be preserved
-  return static_cast<To>(from);
-}  // function
+    // nan and inf will be preserved
+    return static_cast<To>(from);
+  } // function
 
-template <typename To, typename From,
-          FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
-  ec = 0;
-  static_assert(std::is_floating_point<From>::value, "From must be floating");
-  return from;
-}
-
-/**
- * safe duration cast between integral durations
- */
-template <typename To, typename FromRep, typename FromPeriod,
-          FMT_ENABLE_IF(std::is_integral<FromRep>::value),
-          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
-To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                      int& ec) {
-  using From = std::chrono::duration<FromRep, FromPeriod>;
-  ec = 0;
-  // the basic idea is that we need to convert from count() in the from type
-  // to count() in the To type, by multiplying it with this:
-  using Factor = std::ratio_divide<typename From::period, typename To::period>;
-
-  static_assert(Factor::num > 0, "num must be positive");
-  static_assert(Factor::den > 0, "den must be positive");
-
-  // the conversion is like this: multiply from.count() with Factor::num
-  // /Factor::den and convert it to To::rep, all this without
-  // overflow/underflow. let's start by finding a suitable type that can hold
-  // both To, From and Factor::num
-  using IntermediateRep =
-      typename std::common_type<typename From::rep, typename To::rep,
-                                decltype(Factor::num)>::type;
-
-  // safe conversion to IntermediateRep
-  IntermediateRep count =
-      lossless_integral_conversion<IntermediateRep>(from.count(), ec);
-  if (ec) {
-    return {};
+  template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)>
+  FMT_CONSTEXPR To safe_float_conversion(const From from, int &ec)
+  {
+    ec = 0;
+    static_assert(std::is_floating_point<From>::value, "From must be floating");
+    return from;
   }
-  // multiply with Factor::num without overflow or underflow
-  if (Factor::num != 1) {
-    constexpr auto max1 =
-        std::numeric_limits<IntermediateRep>::max() / Factor::num;
-    if (count > max1) {
-      ec = 1;
+
+  /**
+   * safe duration cast between integral durations
+   */
+  template <typename To, typename FromRep, typename FromPeriod,
+            FMT_ENABLE_IF(std::is_integral<FromRep>::value),
+            FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
+  To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int &ec)
+  {
+    using From = std::chrono::duration<FromRep, FromPeriod>;
+    ec         = 0;
+    // the basic idea is that we need to convert from count() in the from type
+    // to count() in the To type, by multiplying it with this:
+    struct Factor : std::ratio_divide<typename From::period, typename To::period>
+    {
+    };
+
+    static_assert(Factor::num > 0, "num must be positive");
+    static_assert(Factor::den > 0, "den must be positive");
+
+    // the conversion is like this: multiply from.count() with Factor::num
+    // /Factor::den and convert it to To::rep, all this without
+    // overflow/underflow. let's start by finding a suitable type that can hold
+    // both To, From and Factor::num
+    using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep,
+                                                      decltype(Factor::num)>::type;
+
+    // safe conversion to IntermediateRep
+    IntermediateRep count = lossless_integral_conversion<IntermediateRep>(from.count(), ec);
+    if (ec) {
       return {};
     }
-    constexpr auto min1 =
-        std::numeric_limits<IntermediateRep>::min() / Factor::num;
-    if (count < min1) {
-      ec = 1;
-      return {};
+    // multiply with Factor::num without overflow or underflow
+    if (Factor::num != 1) {
+      const auto max1 = internal::max_value<IntermediateRep>() / Factor::num;
+      if (count > max1) {
+        ec = 1;
+        return {};
+      }
+      const auto min1 = std::numeric_limits<IntermediateRep>::min() / Factor::num;
+      if (count < min1) {
+        ec = 1;
+        return {};
+      }
+      count *= Factor::num;
     }
-    count *= Factor::num;
-  }
-
-  // this can't go wrong, right? den>0 is checked earlier.
-  if (Factor::den != 1) {
-    count /= Factor::den;
-  }
-  // convert to the to type, safely
-  using ToRep = typename To::rep;
-  const ToRep tocount = lossless_integral_conversion<ToRep>(count, ec);
-  if (ec) {
-    return {};
-  }
-  return To{tocount};
-}
 
-/**
- * safe duration_cast between floating point durations
- */
-template <typename To, typename FromRep, typename FromPeriod,
-          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
-          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
-To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                      int& ec) {
-  using From = std::chrono::duration<FromRep, FromPeriod>;
-  ec = 0;
-  if (std::isnan(from.count())) {
-    // nan in, gives nan out. easy.
-    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+    // this can't go wrong, right? den>0 is checked earlier.
+    if (Factor::den != 1) {
+      count /= Factor::den;
+    }
+    // convert to the to type, safely
+    using ToRep         = typename To::rep;
+    const ToRep tocount = lossless_integral_conversion<ToRep>(count, ec);
+    if (ec) {
+      return {};
+    }
+    return To{tocount};
   }
-  // maybe we should also check if from is denormal, and decide what to do about
-  // it.
 
-  // +-inf should be preserved.
-  if (std::isinf(from.count())) {
-    return To{from.count()};
-  }
+  /**
+   * safe duration_cast between floating point durations
+   */
+  template <typename To, typename FromRep, typename FromPeriod,
+            FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
+            FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
+  To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int &ec)
+  {
+    using From = std::chrono::duration<FromRep, FromPeriod>;
+    ec         = 0;
+    if (std::isnan(from.count())) {
+      // nan in, gives nan out. easy.
+      return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+    }
+    // maybe we should also check if from is denormal, and decide what to do about
+    // it.
 
-  // the basic idea is that we need to convert from count() in the from type
-  // to count() in the To type, by multiplying it with this:
-  using Factor = std::ratio_divide<typename From::period, typename To::period>;
-
-  static_assert(Factor::num > 0, "num must be positive");
-  static_assert(Factor::den > 0, "den must be positive");
-
-  // the conversion is like this: multiply from.count() with Factor::num
-  // /Factor::den and convert it to To::rep, all this without
-  // overflow/underflow. let's start by finding a suitable type that can hold
-  // both To, From and Factor::num
-  using IntermediateRep =
-      typename std::common_type<typename From::rep, typename To::rep,
-                                decltype(Factor::num)>::type;
-
-  // force conversion of From::rep -> IntermediateRep to be safe,
-  // even if it will never happen be narrowing in this context.
-  IntermediateRep count =
-      safe_float_conversion<IntermediateRep>(from.count(), ec);
-  if (ec) {
-    return {};
-  }
+    // +-inf should be preserved.
+    if (std::isinf(from.count())) {
+      return To{from.count()};
+    }
 
-  // multiply with Factor::num without overflow or underflow
-  if (Factor::num != 1) {
-    constexpr auto max1 = std::numeric_limits<IntermediateRep>::max() /
-                          static_cast<IntermediateRep>(Factor::num);
-    if (count > max1) {
-      ec = 1;
+    // the basic idea is that we need to convert from count() in the from type
+    // to count() in the To type, by multiplying it with this:
+    struct Factor : std::ratio_divide<typename From::period, typename To::period>
+    {
+    };
+
+    static_assert(Factor::num > 0, "num must be positive");
+    static_assert(Factor::den > 0, "den must be positive");
+
+    // the conversion is like this: multiply from.count() with Factor::num
+    // /Factor::den and convert it to To::rep, all this without
+    // overflow/underflow. let's start by finding a suitable type that can hold
+    // both To, From and Factor::num
+    using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep,
+                                                      decltype(Factor::num)>::type;
+
+    // force conversion of From::rep -> IntermediateRep to be safe,
+    // even if it will never happen be narrowing in this context.
+    IntermediateRep count = safe_float_conversion<IntermediateRep>(from.count(), ec);
+    if (ec) {
       return {};
     }
-    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
-                          static_cast<IntermediateRep>(Factor::num);
-    if (count < min1) {
-      ec = 1;
-      return {};
+
+    // multiply with Factor::num without overflow or underflow
+    if (Factor::num != 1) {
+      constexpr auto max1 =
+          internal::max_value<IntermediateRep>() / static_cast<IntermediateRep>(Factor::num);
+      if (count > max1) {
+        ec = 1;
+        return {};
+      }
+      constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
+                            static_cast<IntermediateRep>(Factor::num);
+      if (count < min1) {
+        ec = 1;
+        return {};
+      }
+      count *= static_cast<IntermediateRep>(Factor::num);
     }
-    count *= static_cast<IntermediateRep>(Factor::num);
-  }
 
-  // this can't go wrong, right? den>0 is checked earlier.
-  if (Factor::den != 1) {
-    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
-    count /= static_cast<common_t>(Factor::den);
-  }
+    // this can't go wrong, right? den>0 is checked earlier.
+    if (Factor::den != 1) {
+      using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
+      count /= static_cast<common_t>(Factor::den);
+    }
 
-  // convert to the to type, safely
-  using ToRep = typename To::rep;
+    // convert to the to type, safely
+    using ToRep = typename To::rep;
 
-  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
-  if (ec) {
-    return {};
+    const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
+    if (ec) {
+      return {};
+    }
+    return To{tocount};
   }
-  return To{tocount};
-}
 
-}  // namespace safe_duration_cast
+} // namespace safe_duration_cast
 
 FMT_END_NAMESPACE
diff --git a/packages/seacas/libraries/ioss/src/hash/bhopscotch_map.h b/packages/seacas/libraries/ioss/src/hash/bhopscotch_map.h
index dee8e33c2a14..a278904f8543 100644
--- a/packages/seacas/libraries/ioss/src/hash/bhopscotch_map.h
+++ b/packages/seacas/libraries/ioss/src/hash/bhopscotch_map.h
@@ -324,7 +324,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup to the value if you already
+     * the same as hash_function()(key). Useful to speed-up the lookup to the value if you already
      * have the hash.
      */
     size_type erase(const key_type &key, std::size_t precalculated_hash)
@@ -349,7 +349,7 @@ namespace tsl {
      * @copydoc erase(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup to the value if you already
+     * the same as hash_function()(key). Useful to speed-up the lookup to the value if you already
      * have the hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -369,7 +369,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     T &at(const Key &key, std::size_t precalculated_hash)
@@ -404,7 +404,7 @@ namespace tsl {
      * @copydoc at(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -444,7 +444,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     size_type count(const Key &key, std::size_t precalculated_hash) const
@@ -469,7 +469,7 @@ namespace tsl {
      * @copydoc count(const K& key) const
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -484,7 +484,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     iterator find(const Key &key, std::size_t precalculated_hash)
@@ -519,7 +519,7 @@ namespace tsl {
      * @copydoc find(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -556,7 +556,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     bool contains(const Key &key, std::size_t precalculated_hash) const
@@ -579,7 +579,7 @@ namespace tsl {
      * @copydoc contains(const K& key) const
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual,
@@ -593,7 +593,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     std::pair<iterator, iterator> equal_range(const Key &key, std::size_t precalculated_hash)
@@ -632,7 +632,7 @@ namespace tsl {
      * @copydoc equal_range(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
diff --git a/packages/seacas/libraries/ioss/src/hash/bhopscotch_set.h b/packages/seacas/libraries/ioss/src/hash/bhopscotch_set.h
index 0c3c584d45dc..61879c688d78 100644
--- a/packages/seacas/libraries/ioss/src/hash/bhopscotch_set.h
+++ b/packages/seacas/libraries/ioss/src/hash/bhopscotch_set.h
@@ -243,7 +243,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup to the value if you already
+     * the same as hash_function()(key). Useful to speed-up the lookup to the value if you already
      * have the hash.
      */
     size_type erase(const key_type &key, std::size_t precalculated_hash)
@@ -268,7 +268,7 @@ namespace tsl {
      * @copydoc erase(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup to the value if you already
+     * the same as hash_function()(key). Useful to speed-up the lookup to the value if you already
      * have the hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -288,7 +288,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     size_type count(const Key &key, std::size_t precalculated_hash) const
@@ -313,7 +313,7 @@ namespace tsl {
      * @copydoc count(const K& key) const
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -328,7 +328,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     iterator find(const Key &key, std::size_t precalculated_hash)
@@ -363,7 +363,7 @@ namespace tsl {
      * @copydoc find(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -389,7 +389,7 @@ namespace tsl {
      * @copydoc find(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
@@ -404,7 +404,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     bool contains(const Key &key, std::size_t precalculated_hash) const
@@ -427,7 +427,7 @@ namespace tsl {
      * @copydoc contains(const K& key) const
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual,
@@ -441,7 +441,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     std::pair<iterator, iterator> equal_range(const Key &key, std::size_t precalculated_hash)
@@ -480,7 +480,7 @@ namespace tsl {
      * @copydoc equal_range(const K& key)
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual, class CP = Compare,
diff --git a/packages/seacas/libraries/ioss/src/hash/hopscotch_hash.h b/packages/seacas/libraries/ioss/src/hash/hopscotch_hash.h
index 2a8b7f3d1cd5..6971dec7bf8d 100644
--- a/packages/seacas/libraries/ioss/src/hash/hopscotch_hash.h
+++ b/packages/seacas/libraries/ioss/src/hash/hopscotch_hash.h
@@ -1831,7 +1831,7 @@ namespace tsl {
       /**
        * Min size of the hash table before a rehash can occurs automatically (except if
        * m_max_load_threshold_rehash os reached). If the neighborhood of a bucket is full before the
-       * min is reached, the elements are put into m_overflow_elements.
+       * min is reacher, the elements are put into m_overflow_elements.
        */
       size_type m_min_load_threshold_rehash;
     };
diff --git a/packages/seacas/libraries/ioss/src/hash/hopscotch_map.h b/packages/seacas/libraries/ioss/src/hash/hopscotch_map.h
index f88785b6e15a..f192e6225551 100644
--- a/packages/seacas/libraries/ioss/src/hash/hopscotch_map.h
+++ b/packages/seacas/libraries/ioss/src/hash/hopscotch_map.h
@@ -553,7 +553,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     bool contains(const Key &key, std::size_t precalculated_hash) const
@@ -576,7 +576,7 @@ namespace tsl {
      * @copydoc contains(const K& key) const
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual,
diff --git a/packages/seacas/libraries/ioss/src/hash/hopscotch_set.h b/packages/seacas/libraries/ioss/src/hash/hopscotch_set.h
index 262a52a571dd..bb068220e13c 100644
--- a/packages/seacas/libraries/ioss/src/hash/hopscotch_set.h
+++ b/packages/seacas/libraries/ioss/src/hash/hopscotch_set.h
@@ -405,7 +405,7 @@ namespace tsl {
 
     /**
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     bool contains(const Key &key, std::size_t precalculated_hash) const
@@ -428,7 +428,7 @@ namespace tsl {
      * @copydoc contains(const K& key) const
      *
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be
-     * the same as hash_function()(key). Usefull to speed-up the lookup if you already have the
+     * the same as hash_function()(key). Useful to speed-up the lookup if you already have the
      * hash.
      */
     template <class K, class KE = KeyEqual,
diff --git a/packages/seacas/libraries/ioss/src/hash/robin_set.h b/packages/seacas/libraries/ioss/src/hash/robin_set.h
index df98e4092aa4..63736dd798bd 100644
--- a/packages/seacas/libraries/ioss/src/hash/robin_set.h
+++ b/packages/seacas/libraries/ioss/src/hash/robin_set.h
@@ -136,9 +136,9 @@ namespace tsl {
     explicit robin_set(const Allocator &alloc) : robin_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {}
 
     template <class InputIt>
-    robin_set(InputIt first, InputIt last, size_type my_bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
-              const Hash &hash = Hash(), const KeyEqual &equal = KeyEqual(),
-              const Allocator &alloc = Allocator())
+    robin_set(InputIt first, InputIt last,
+              size_type my_bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE, const Hash &hash = Hash(),
+              const KeyEqual &equal = KeyEqual(), const Allocator &alloc = Allocator())
         : robin_set(my_bucket_count, hash, equal, alloc)
     {
       insert(first, last);
diff --git a/packages/seacas/libraries/ioss/src/heartbeat/Iohb_DatabaseIO.C b/packages/seacas/libraries/ioss/src/heartbeat/Iohb_DatabaseIO.C
index 5ee8d45d01d9..5a66563590d7 100644
--- a/packages/seacas/libraries/ioss/src/heartbeat/Iohb_DatabaseIO.C
+++ b/packages/seacas/libraries/ioss/src/heartbeat/Iohb_DatabaseIO.C
@@ -126,10 +126,10 @@ namespace {
       // 'logger' class which handles sharing and destruction...
       std::ofstream *tmp = nullptr;
       if (append_file) {
-        tmp = new std::ofstream(filename.c_str(), std::ios::out | std::ios::app);
+        tmp = new std::ofstream(filename, std::ios::out | std::ios::app);
       }
       else {
-        tmp = new std::ofstream(filename.c_str());
+        tmp = new std::ofstream(filename);
       }
       if (!tmp->is_open()) {
         delete tmp;
@@ -190,19 +190,19 @@ namespace Iohb {
 
       if (properties.exists("FILE_FORMAT")) {
         std::string format = properties.get("FILE_FORMAT").get_string();
-        if (Ioss::Utils::case_strcmp(format, "spyhis") == 0) {
+        if (Ioss::Utils::str_equal(format, "spyhis")) {
           new_this->fileFormat = SPYHIS;
         }
-        else if (Ioss::Utils::case_strcmp(format, "csv") == 0) {
+        else if (Ioss::Utils::str_equal(format, "csv")) {
           new_this->fileFormat = CSV;
         }
-        else if (Ioss::Utils::case_strcmp(format, "ts_csv") == 0) {
+        else if (Ioss::Utils::str_equal(format, "ts_csv")) {
           new_this->fileFormat = TS_CSV;
         }
-        else if (Ioss::Utils::case_strcmp(format, "text") == 0) {
+        else if (Ioss::Utils::str_equal(format, "text")) {
           new_this->fileFormat = TEXT;
         }
-        else if (Ioss::Utils::case_strcmp(format, "ts_text") == 0) {
+        else if (Ioss::Utils::str_equal(format, "ts_text")) {
           new_this->fileFormat = TS_TEXT;
         }
       }
diff --git a/packages/seacas/libraries/ioss/src/main/CMakeLists.txt b/packages/seacas/libraries/ioss/src/main/CMakeLists.txt
index 81bd16bbe5e3..4201e0f2d900 100644
--- a/packages/seacas/libraries/ioss/src/main/CMakeLists.txt
+++ b/packages/seacas/libraries/ioss/src/main/CMakeLists.txt
@@ -110,7 +110,6 @@ if (TPL_ENABLE_MPI)
   XHOSTTYPE Windows
   )
 endif()
-endif()
 
 TRIBITS_ADD_ADVANCED_TEST(exodus32_to_exodus64
    TEST_0 EXEC io_shell ARGS -64 ${DECOMP_ARG} ${JOIN_ARG} ${CMAKE_CURRENT_SOURCE_DIR}/test/8-block.g 8-block64.g
@@ -160,6 +159,7 @@ ELSE()
 ENDIF()
 ENDIF()
 ENDIF()
+ENDIF()
 
 IF (TPL_ENABLE_Pamgen OR Trilinos_ENABLE_Pamgen)
 # This test makes sure that the adjacency information (what element blocks are adjacent to what other
diff --git a/packages/seacas/libraries/ioss/src/main/cth_pressure_map.C b/packages/seacas/libraries/ioss/src/main/cth_pressure_map.C
index 563081eb01a8..b1f7ef06e18a 100644
--- a/packages/seacas/libraries/ioss/src/main/cth_pressure_map.C
+++ b/packages/seacas/libraries/ioss/src/main/cth_pressure_map.C
@@ -280,7 +280,7 @@ int main(int argc, char *argv[])
   }
 
   if (!input_file.empty()) {
-    std::ifstream input(input_file.c_str());
+    std::ifstream input(input_file);
     if (!input) {
       std::cerr << "Error opening file '" << input_file << "'.\n";
       show_usage(codename, globals.add_sset);
@@ -799,8 +799,7 @@ namespace {
     for (IF = fields.begin(); IF != fields.end(); ++IF) {
       std::string field_name = *IF;
       if (field_name != "ids" && !oge->field_exists(field_name) &&
-          (prefix.empty() ||
-           std::strncmp(prefix.c_str(), field_name.c_str(), prefix.length()) == 0)) {
+          Ioss::Utils::substr_equal(prefix, field_name)) {
         // If the field does not already exist, add it to the output node block
         Ioss::Field field = ige->get_field(field_name);
         oge->field_add(field);
@@ -841,8 +840,7 @@ namespace {
         continue;
       }
 
-      if (field_name != "ids" && (prefix.empty() || std::strncmp(prefix.c_str(), field_name.c_str(),
-                                                                 prefix.length()) == 0)) {
+      if (field_name != "ids" && Ioss::Utils::substr_equal(prefix, field_name)) {
         assert(oge->field_exists(field_name));
         transfer_field_data_internal(ige, oge, field_name);
       }
@@ -1052,7 +1050,7 @@ namespace {
           // NOTE: Only dealing with the "cth_" fields here.
           // If there are other fields, we probably have an invalid
           // output database...
-          if (std::strncmp("cth_", field_name.c_str(), 4) == 0) {
+          if (Ioss::Utils::substr_equal("cth_", field_name)) {
             int isize = (*i)->get_field(field_name).get_size();
             int count = (*i)->get_field(field_name).raw_count();
             data.resize(isize);
@@ -1136,7 +1134,7 @@ namespace {
             }
             fb->put_field_data(field_name, &data[0], isize);
           }
-          else if (std::strncmp("cth_", field_name.c_str(), 4) == 0) {
+          else if (Ioss::Utils::substr_equal("cth_", field_name)) {
             assert(fb->field_exists(field_name));
             transfer_field_data_internal(*i, fb, field_name);
           }
@@ -1188,7 +1186,7 @@ namespace {
 
         for (IF = state_fields.begin(); IF != state_fields.end(); ++IF) {
           std::string field_name = *IF;
-          if (std::strncmp("cth_", field_name.c_str(), 4) == 0) {
+          if (Ioss::Utils::substr_equal("cth_", field_name)) {
             if (field_name == cth_pressure &&
                 (globals.final_pressure == Globals::ZERO ||
                  globals.final_pressure == Globals::OFFSET || globals.convert_gage)) {
diff --git a/packages/seacas/libraries/ioss/src/main/io_shell_ts.C b/packages/seacas/libraries/ioss/src/main/io_shell_ts.C
index 780179787b9a..49521922a81d 100644
--- a/packages/seacas/libraries/ioss/src/main/io_shell_ts.C
+++ b/packages/seacas/libraries/ioss/src/main/io_shell_ts.C
@@ -1078,8 +1078,7 @@ namespace {
     for (const auto &field_name : fields) {
       Ioss::Field field = ige->get_field(field_name);
       if (field_name != "ids" && !oge->field_exists(field_name) &&
-          (prefix.empty() ||
-           std::strncmp(prefix.c_str(), field_name.c_str(), prefix.length()) == 0)) {
+          Ioss::Utils::substr_equal(prefix, field_name)) {
         // If the field does not already exist, add it to the output node block
         oge->field_add(field);
       }
@@ -1358,8 +1357,7 @@ namespace {
         continue;
       }
 
-      if (field_name != "ids" && (prefix.empty() || std::strncmp(prefix.c_str(), field_name.c_str(),
-                                                                 prefix.length()) == 0)) {
+      if (field_name != "ids" && Ioss::Utils::substr_equal(prefix, field_name)) {
         assert(oge->field_exists(field_name));
         transfer_field_data_internal(ige, oge, field_name, interFace);
       }
diff --git a/packages/seacas/libraries/ioss/src/main/shell_to_hex.C b/packages/seacas/libraries/ioss/src/main/shell_to_hex.C
index eb6dad06a259..3568d590f6c4 100644
--- a/packages/seacas/libraries/ioss/src/main/shell_to_hex.C
+++ b/packages/seacas/libraries/ioss/src/main/shell_to_hex.C
@@ -94,7 +94,7 @@ namespace {
 
 namespace {
   std::string codename;
-  std::string version = "$Revision$";
+  std::string version = "0.9";
 } // namespace
 
 int main(int argc, char *argv[])
@@ -121,7 +121,7 @@ int main(int argc, char *argv[])
 
   // Check the program name to see if of the form 'exosaf' or 'safexo'
   // and if it is, set the in_type and out_type accordingly...
-  if (std::strncmp(codename.c_str(), "shell_to_hex", 12) == 0) {
+  if (Ioss::Utils::str_equal(codename, "shell_to_hex")) {
     codename           = "shell_to_hex";
     in_type            = "exodusII";
     out_type           = "exodusII";
@@ -189,7 +189,7 @@ int main(int argc, char *argv[])
     std::string input_file =
         Ioss::Utils::local_filename(argv[i++], "text", globals.working_directory);
 
-    std::ifstream input(input_file.c_str());
+    std::ifstream input(input_file);
     if (!input) {
       std::cerr << "Error opening file '" << input_file << "'.\n";
       show_usage(codename);
diff --git a/packages/seacas/libraries/ioss/src/pamgen/Iopg_DatabaseIO.C b/packages/seacas/libraries/ioss/src/pamgen/Iopg_DatabaseIO.C
index 4d9c8eea8517..9e1ec9a36bf5 100644
--- a/packages/seacas/libraries/ioss/src/pamgen/Iopg_DatabaseIO.C
+++ b/packages/seacas/libraries/ioss/src/pamgen/Iopg_DatabaseIO.C
@@ -209,7 +209,7 @@ namespace Iopg {
       }
     }
     else {
-      std::ifstream f(get_filename().c_str());
+      std::ifstream f(get_filename());
       if (!f) {
         std::ostringstream errmsg;
         errmsg << "Error opening file '" << get_filename() << "'.";
diff --git a/packages/seacas/libraries/ioss/src/utest/Utst_utils.C b/packages/seacas/libraries/ioss/src/utest/Utst_utils.C
index 0281a2c99a26..17108a7ee885 100644
--- a/packages/seacas/libraries/ioss/src/utest/Utst_utils.C
+++ b/packages/seacas/libraries/ioss/src/utest/Utst_utils.C
@@ -51,6 +51,41 @@ TEST_CASE("number_width", "[number_width]")
   }
 }
 
+TEST_CASE("str_equal", "[str_equal]")
+{
+  REQUIRE(Ioss::Utils::str_equal("", ""));
+  REQUIRE(!Ioss::Utils::str_equal("", "a"));
+  REQUIRE(!Ioss::Utils::str_equal("a", ""));
+  REQUIRE(Ioss::Utils::str_equal("a", "a"));
+  REQUIRE(Ioss::Utils::str_equal("A", "a"));
+  REQUIRE(Ioss::Utils::str_equal("a", "A"));
+
+  REQUIRE(Ioss::Utils::str_equal("longer_than_single_character", "longer_than_single_character"));
+  REQUIRE(Ioss::Utils::str_equal("longer_than_single_character", "LONGER_THAN_SINGLE_CHARACTER"));
+  REQUIRE(Ioss::Utils::str_equal("LONGER_THAN_SINGLE_CHARACTER", "longer_than_single_character"));
+  REQUIRE(Ioss::Utils::str_equal("LONGER_THAN_SINGLE_CHARACTER", "LONGER_THAN_SINGLE_CHARACTER"));
+  REQUIRE(Ioss::Utils::str_equal("LoNgEr_ThAn_SiNgLe_ChArAcTeR", "lOnGeR_tHaN_sInGlE_cHaRaCtEr"));
+
+  REQUIRE(!Ioss::Utils::str_equal("Almost_The_Same", "almost_the_sam"));
+}
+
+TEST_CASE("substr_equal", "[substr_equal]")
+{
+  REQUIRE(Ioss::Utils::substr_equal("", ""));
+  REQUIRE(Ioss::Utils::substr_equal("", "a"));
+  REQUIRE(!Ioss::Utils::substr_equal("a", ""));
+  REQUIRE(Ioss::Utils::substr_equal("a", "a"));
+  REQUIRE(Ioss::Utils::substr_equal("A", "a"));
+  REQUIRE(Ioss::Utils::substr_equal("a", "A"));
+
+  REQUIRE(!Ioss::Utils::substr_equal("prefix", "pref"));
+  REQUIRE(Ioss::Utils::substr_equal("prefix", "PREFIX"));
+  REQUIRE(Ioss::Utils::substr_equal("pre", "PREFIX"));
+  REQUIRE(Ioss::Utils::substr_equal("pre", "prefix"));
+  REQUIRE(Ioss::Utils::substr_equal("PRe", "prefix"));
+  REQUIRE(Ioss::Utils::substr_equal("PRe", "PREFIX"));
+}
+
 TEST_CASE("format_id_list", "[format_id_list]")
 {
   SECTION("ids_empty")
diff --git a/packages/seacas/libraries/suplib_cpp/GetLongOpt.C b/packages/seacas/libraries/suplib_cpp/GetLongOpt.C
index de3e3e1e09f2..22627d908696 100644
--- a/packages/seacas/libraries/suplib_cpp/GetLongOpt.C
+++ b/packages/seacas/libraries/suplib_cpp/GetLongOpt.C
@@ -23,10 +23,8 @@ GetLongOption::~GetLongOption()
 
 char *GetLongOption::basename(char *const pathname)
 {
-  char *s;
-
-  s = strrchr(pathname, '/');
-  if (s == 0) {
+  char *s = strrchr(pathname, '/');
+  if (s == nullptr) {
     s = pathname;
   }
   else {
@@ -49,9 +47,9 @@ int GetLongOption::enroll(const char *const opt, const OptType t, const char *co
   c->description = desc != nullptr ? desc : "no description available";
   c->value       = val;
   c->opt_value   = optval;
-  c->next        = 0;
+  c->next        = nullptr;
 
-  if (last == 0) {
+  if (last == nullptr) {
     table = last = c;
   }
   else {
@@ -65,14 +63,14 @@ int GetLongOption::enroll(const char *const opt, const OptType t, const char *co
 const char *GetLongOption::retrieve(const char *const opt) const
 {
   Cell *t;
-  for (t = table; t != 0; t = t->next) {
+  for (t = table; t != nullptr; t = t->next) {
     if (strcmp(opt, t->option) == 0) {
       return t->value;
     }
   }
   std::cerr << "GetLongOption::retrieve - unenrolled option ";
   std::cerr << optmarker << opt << "\n";
-  return 0;
+  return nullptr;
 }
 
 int GetLongOption::parse(int argc, char *const *argv)
@@ -110,8 +108,8 @@ int GetLongOption::parse(int argc, char *const *argv)
     enum { NoMatch, ExactMatch, PartialMatch, MultipleMatch } matchStatus = NoMatch;
 
     std::ostringstream errmsg;
-    Cell *             pc = 0; // pointer to the partially-matched cell
-    for (t = table; t != 0; t = t->next) {
+    Cell *             pc = nullptr; // pointer to the partially-matched cell
+    for (t = table; t != nullptr; t = t->next) {
       if (strncmp(t->option, token, (tmptoken - token)) == 0) {
         if (static_cast<int>(strlen(t->option)) == (tmptoken - token)) {
           /* an exact match found */
@@ -129,7 +127,7 @@ int GetLongOption::parse(int argc, char *const *argv)
         }
         else {
           /* partial match found */
-          if (pc == 0) {
+          if (pc == nullptr) {
             matchStatus = PartialMatch;
             pc          = t;
           }
@@ -187,7 +185,7 @@ int GetLongOption::parse(char *const str, char *const p)
       return -1; /* end of options */
     }
 
-    char *ladtoken = 0; /* lookahead token */
+    char *ladtoken = nullptr; /* lookahead token */
     char *tmptoken = ++token;
     while ((*tmptoken != 0) && *tmptoken != '=') {
       ++tmptoken;
@@ -197,18 +195,18 @@ int GetLongOption::parse(char *const str, char *const p)
 
     Cell *t;
     enum { NoMatch, ExactMatch, PartialMatch } matchStatus = NoMatch;
-    Cell *pc = 0; // pointer to the partially-matched cell
-    for (t = table; t != 0; t = t->next) {
+    Cell *pc = nullptr; // pointer to the partially-matched cell
+    for (t = table; t != nullptr; t = t->next) {
       if (strncmp(t->option, token, (tmptoken - token)) == 0) {
         if (static_cast<int>(strlen(t->option)) == (tmptoken - token)) {
           /* an exact match found */
-          ladtoken = strtok(0, " \t");
+          ladtoken = strtok(nullptr, " \t");
           int stat = setcell(t, tmptoken, ladtoken, name);
           if (stat == -1) {
             return -1;
           }
           if (stat == 1) {
-            ladtoken = 0;
+            ladtoken = nullptr;
           }
           matchStatus = ExactMatch;
           break;
@@ -222,13 +220,13 @@ int GetLongOption::parse(char *const str, char *const p)
     }   /* end for */
 
     if (matchStatus == PartialMatch) {
-      ladtoken = strtok(0, " \t");
+      ladtoken = strtok(nullptr, " \t");
       int stat = setcell(pc, tmptoken, ladtoken, name);
       if (stat == -1) {
         return -1;
       }
       if (stat == 1) {
-        ladtoken = 0;
+        ladtoken = nullptr;
       }
     }
     else if (matchStatus == NoMatch) {
@@ -237,7 +235,7 @@ int GetLongOption::parse(char *const str, char *const p)
       return -1; /* no match */
     }
 
-    token = ladtoken != nullptr ? ladtoken : strtok(0, " \t");
+    token = ladtoken != nullptr ? ladtoken : strtok(nullptr, " \t");
   } /* end while */
 
   return 1;
@@ -252,7 +250,7 @@ GetLongOption::setcell returns
 
 int GetLongOption::setcell(Cell *c, char *valtoken, char *nexttoken, const char *name)
 {
-  if (c == 0) {
+  if (c == nullptr) {
     return -1;
   }
 
@@ -273,7 +271,7 @@ int GetLongOption::setcell(Cell *c, char *valtoken, char *nexttoken, const char
       return 0;
     }
     else {
-      if (nexttoken != 0 && nexttoken[0] != optmarker) {
+      if (nexttoken != nullptr && nexttoken[0] != optmarker) {
         c->value = nexttoken;
         return 1;
       }
@@ -288,7 +286,7 @@ int GetLongOption::setcell(Cell *c, char *valtoken, char *nexttoken, const char
     }
     else {
       // KLUGE for exodiff "-steps -1" parsing.  need to do a better way...
-      if (nexttoken != 0 && (nexttoken[0] != optmarker || nexttoken[1] == '1')) {
+      if (nexttoken != nullptr && (nexttoken[0] != optmarker || nexttoken[1] == '1')) {
         c->value = nexttoken;
         return 1;
       }
@@ -307,7 +305,7 @@ void GetLongOption::usage(std::ostream &outfile) const
   Cell *t;
 
   outfile << "\nusage: " << pname << " " << ustring << "\n";
-  for (t = table; t != 0; t = t->next) {
+  for (t = table; t != nullptr; t = t->next) {
     outfile << "\t" << optmarker << t->option;
     if (t->type == GetLongOption::MandatoryValue) {
       outfile << " <$val>";
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/chrono.h b/packages/seacas/libraries/suplib_cpp/fmt/chrono.h
index 9ff8ad754db7..8d23eac0484b 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/chrono.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/chrono.h
@@ -18,11 +18,11 @@
 
 // enable safe chrono durations, unless explicitly disabled
 #ifndef FMT_SAFE_DURATION_CAST
-#  define FMT_SAFE_DURATION_CAST 1
+#define FMT_SAFE_DURATION_CAST 1
 #endif
 
 #if FMT_SAFE_DURATION_CAST
-#  include "safe-duration-cast.h"
+#include "safe-duration-cast.h"
 #endif
 
 FMT_BEGIN_NAMESPACE
@@ -32,28 +32,32 @@ FMT_BEGIN_NAMESPACE
 #define FMT_NOMACRO
 
 namespace internal {
-inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
-inline null<> localtime_s(...) { return null<>(); }
-inline null<> gmtime_r(...) { return null<>(); }
-inline null<> gmtime_s(...) { return null<>(); }
-}  // namespace internal
+  inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
+  inline null<>             localtime_s(...) { return null<>(); }
+  inline null<>             gmtime_r(...) { return null<>(); }
+  inline null<>             gmtime_s(...) { return null<>(); }
+} // namespace internal
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time) {
-  struct dispatcher {
+inline std::tm localtime(std::time_t time)
+{
+  struct dispatcher
+  {
     std::time_t time_;
-    std::tm tm_;
+    std::tm     tm_;
 
     dispatcher(std::time_t t) : time_(t) {}
 
-    bool run() {
+    bool run()
+    {
       using namespace fmt::internal;
       return handle(localtime_r(&time_, &tm_));
     }
 
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    bool handle(std::tm *tm) { return tm != nullptr; }
 
-    bool handle(internal::null<>) {
+    bool handle(internal::null<>)
+    {
       using namespace fmt::internal;
       return fallback(localtime_s(&tm_, &time_));
     }
@@ -61,36 +65,43 @@ inline std::tm localtime(std::time_t time) {
     bool fallback(int res) { return res == 0; }
 
 #if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
+    bool fallback(internal::null<>)
+    {
       using namespace fmt::internal;
-      std::tm* tm = std::localtime(&time_);
-      if (tm) tm_ = *tm;
+      std::tm *tm = std::localtime(&time_);
+      if (tm)
+        tm_ = *tm;
       return tm != nullptr;
     }
 #endif
   };
   dispatcher lt(time);
   // Too big time values may be unsupported.
-  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
+  if (!lt.run())
+    FMT_THROW(format_error("time_t value out of range"));
   return lt.tm_;
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time) {
-  struct dispatcher {
+inline std::tm gmtime(std::time_t time)
+{
+  struct dispatcher
+  {
     std::time_t time_;
-    std::tm tm_;
+    std::tm     tm_;
 
     dispatcher(std::time_t t) : time_(t) {}
 
-    bool run() {
+    bool run()
+    {
       using namespace fmt::internal;
       return handle(gmtime_r(&time_, &tm_));
     }
 
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    bool handle(std::tm *tm) { return tm != nullptr; }
 
-    bool handle(internal::null<>) {
+    bool handle(internal::null<>)
+    {
       using namespace fmt::internal;
       return fallback(gmtime_s(&tm_, &time_));
     }
@@ -98,38 +109,45 @@ inline std::tm gmtime(std::time_t time) {
     bool fallback(int res) { return res == 0; }
 
 #if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
-      std::tm* tm = std::gmtime(&time_);
-      if (tm) tm_ = *tm;
+    bool fallback(internal::null<>)
+    {
+      std::tm *tm = std::gmtime(&time_);
+      if (tm)
+        tm_ = *tm;
       return tm != nullptr;
     }
 #endif
   };
   dispatcher gt(time);
   // Too big time values may be unsupported.
-  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
+  if (!gt.run())
+    FMT_THROW(format_error("time_t value out of range"));
   return gt.tm_;
 }
 
 namespace internal {
-inline std::size_t strftime(char* str, std::size_t count, const char* format,
-                            const std::tm* time) {
-  return std::strftime(str, count, format, time);
-}
+  inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
+  {
+    return std::strftime(str, count, format, time);
+  }
 
-inline std::size_t strftime(wchar_t* str, std::size_t count,
-                            const wchar_t* format, const std::tm* time) {
-  return std::wcsftime(str, count, format, time);
-}
-}  // namespace internal
+  inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format,
+                              const std::tm *time)
+  {
+    return std::wcsftime(str, count, format, time);
+  }
+} // namespace internal
 
-template <typename Char> struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+template <typename Char> struct formatter<std::tm, Char>
+{
+  template <typename ParseContext> auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     auto it = ctx.begin();
-    if (it != ctx.end() && *it == ':') ++it;
+    if (it != ctx.end() && *it == ':')
+      ++it;
     auto end = it;
-    while (end != ctx.end() && *end != '}') ++end;
+    while (end != ctx.end() && *end != '}')
+      ++end;
     tm_format.reserve(internal::to_unsigned(end - it + 1));
     tm_format.append(it, end);
     tm_format.push_back('\0');
@@ -137,13 +155,13 @@ template <typename Char> struct formatter<std::tm, Char> {
   }
 
   template <typename FormatContext>
-  auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
+  {
     basic_memory_buffer<Char> buf;
-    std::size_t start = buf.size();
+    std::size_t               start = buf.size();
     for (;;) {
-      std::size_t size = buf.capacity() - start;
-      std::size_t count =
-          internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      std::size_t size  = buf.capacity() - start;
+      std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
       if (count != 0) {
         buf.resize(start + count);
         break;
@@ -165,617 +183,589 @@ template <typename Char> struct formatter<std::tm, Char> {
 };
 
 namespace internal {
-template <typename Period> FMT_CONSTEXPR const char* get_units() {
-  return nullptr;
-}
-template <> FMT_CONSTEXPR const char* get_units<std::atto>() { return "as"; }
-template <> FMT_CONSTEXPR const char* get_units<std::femto>() { return "fs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::pico>() { return "ps"; }
-template <> FMT_CONSTEXPR const char* get_units<std::nano>() { return "ns"; }
-template <> FMT_CONSTEXPR const char* get_units<std::micro>() { return "µs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::milli>() { return "ms"; }
-template <> FMT_CONSTEXPR const char* get_units<std::centi>() { return "cs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::deci>() { return "ds"; }
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<1>>() { return "s"; }
-template <> FMT_CONSTEXPR const char* get_units<std::deca>() { return "das"; }
-template <> FMT_CONSTEXPR const char* get_units<std::hecto>() { return "hs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::kilo>() { return "ks"; }
-template <> FMT_CONSTEXPR const char* get_units<std::mega>() { return "Ms"; }
-template <> FMT_CONSTEXPR const char* get_units<std::giga>() { return "Gs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::tera>() { return "Ts"; }
-template <> FMT_CONSTEXPR const char* get_units<std::peta>() { return "Ps"; }
-template <> FMT_CONSTEXPR const char* get_units<std::exa>() { return "Es"; }
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<60>>() {
-  return "m";
-}
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<3600>>() {
-  return "h";
-}
-
-enum class numeric_system {
-  standard,
-  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
-  alternative
-};
+  template <typename Period> FMT_CONSTEXPR const char *get_units() { return nullptr; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::atto>() { return "as"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::femto>() { return "fs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::pico>() { return "ps"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::nano>() { return "ns"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::micro>() { return "µs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::milli>() { return "ms"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::centi>() { return "cs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::deci>() { return "ds"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::ratio<1>>() { return "s"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::deca>() { return "das"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::hecto>() { return "hs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::kilo>() { return "ks"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::mega>() { return "Ms"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::giga>() { return "Gs"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::tera>() { return "Ts"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::peta>() { return "Ps"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::exa>() { return "Es"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::ratio<60>>() { return "m"; }
+  template <> FMT_CONSTEXPR const char *               get_units<std::ratio<3600>>() { return "h"; }
+
+  enum class numeric_system {
+    standard,
+    // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
+    alternative
+  };
 
-// Parses a put_time-like format string and invokes handler actions.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
-                                              const Char* end,
-                                              Handler&& handler) {
-  auto ptr = begin;
-  while (ptr != end) {
-    auto c = *ptr;
-    if (c == '}') break;
-    if (c != '%') {
-      ++ptr;
-      continue;
-    }
-    if (begin != ptr) handler.on_text(begin, ptr);
-    ++ptr;  // consume '%'
-    if (ptr == end) FMT_THROW(format_error("invalid format"));
-    c = *ptr++;
-    switch (c) {
-    case '%':
-      handler.on_text(ptr - 1, ptr);
-      break;
-    case 'n': {
-      const char newline[] = "\n";
-      handler.on_text(newline, newline + 1);
-      break;
-    }
-    case 't': {
-      const char tab[] = "\t";
-      handler.on_text(tab, tab + 1);
-      break;
-    }
-    // Day of the week:
-    case 'a':
-      handler.on_abbr_weekday();
-      break;
-    case 'A':
-      handler.on_full_weekday();
-      break;
-    case 'w':
-      handler.on_dec0_weekday(numeric_system::standard);
-      break;
-    case 'u':
-      handler.on_dec1_weekday(numeric_system::standard);
-      break;
-    // Month:
-    case 'b':
-      handler.on_abbr_month();
-      break;
-    case 'B':
-      handler.on_full_month();
-      break;
-    // Hour, minute, second:
-    case 'H':
-      handler.on_24_hour(numeric_system::standard);
-      break;
-    case 'I':
-      handler.on_12_hour(numeric_system::standard);
-      break;
-    case 'M':
-      handler.on_minute(numeric_system::standard);
-      break;
-    case 'S':
-      handler.on_second(numeric_system::standard);
-      break;
-    // Other:
-    case 'c':
-      handler.on_datetime(numeric_system::standard);
-      break;
-    case 'x':
-      handler.on_loc_date(numeric_system::standard);
-      break;
-    case 'X':
-      handler.on_loc_time(numeric_system::standard);
-      break;
-    case 'D':
-      handler.on_us_date();
-      break;
-    case 'F':
-      handler.on_iso_date();
-      break;
-    case 'r':
-      handler.on_12_hour_time();
-      break;
-    case 'R':
-      handler.on_24_hour_time();
-      break;
-    case 'T':
-      handler.on_iso_time();
-      break;
-    case 'p':
-      handler.on_am_pm();
-      break;
-    case 'Q':
-      handler.on_duration_value();
-      break;
-    case 'q':
-      handler.on_duration_unit();
-      break;
-    case 'z':
-      handler.on_utc_offset();
-      break;
-    case 'Z':
-      handler.on_tz_name();
-      break;
-    // Alternative representation:
-    case 'E': {
-      if (ptr == end) FMT_THROW(format_error("invalid format"));
-      c = *ptr++;
-      switch (c) {
-      case 'c':
-        handler.on_datetime(numeric_system::alternative);
+  // Parses a put_time-like format string and invokes handler actions.
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_chrono_format(const Char *begin, const Char *end,
+                                                Handler &&handler)
+  {
+    auto ptr = begin;
+    while (ptr != end) {
+      auto c = *ptr;
+      if (c == '}')
         break;
-      case 'x':
-        handler.on_loc_date(numeric_system::alternative);
-        break;
-      case 'X':
-        handler.on_loc_time(numeric_system::alternative);
-        break;
-      default:
-        FMT_THROW(format_error("invalid format"));
+      if (c != '%') {
+        ++ptr;
+        continue;
       }
-      break;
-    }
-    case 'O':
-      if (ptr == end) FMT_THROW(format_error("invalid format"));
+      if (begin != ptr)
+        handler.on_text(begin, ptr);
+      ++ptr; // consume '%'
+      if (ptr == end)
+        FMT_THROW(format_error("invalid format"));
       c = *ptr++;
       switch (c) {
-      case 'w':
-        handler.on_dec0_weekday(numeric_system::alternative);
-        break;
-      case 'u':
-        handler.on_dec1_weekday(numeric_system::alternative);
-        break;
-      case 'H':
-        handler.on_24_hour(numeric_system::alternative);
+      case '%': handler.on_text(ptr - 1, ptr); break;
+      case 'n': {
+        const char newline[] = "\n";
+        handler.on_text(newline, newline + 1);
         break;
-      case 'I':
-        handler.on_12_hour(numeric_system::alternative);
+      }
+      case 't': {
+        const char tab[] = "\t";
+        handler.on_text(tab, tab + 1);
         break;
-      case 'M':
-        handler.on_minute(numeric_system::alternative);
+      }
+      // Day of the week:
+      case 'a': handler.on_abbr_weekday(); break;
+      case 'A': handler.on_full_weekday(); break;
+      case 'w': handler.on_dec0_weekday(numeric_system::standard); break;
+      case 'u': handler.on_dec1_weekday(numeric_system::standard); break;
+      // Month:
+      case 'b': handler.on_abbr_month(); break;
+      case 'B': handler.on_full_month(); break;
+      // Hour, minute, second:
+      case 'H': handler.on_24_hour(numeric_system::standard); break;
+      case 'I': handler.on_12_hour(numeric_system::standard); break;
+      case 'M': handler.on_minute(numeric_system::standard); break;
+      case 'S': handler.on_second(numeric_system::standard); break;
+      // Other:
+      case 'c': handler.on_datetime(numeric_system::standard); break;
+      case 'x': handler.on_loc_date(numeric_system::standard); break;
+      case 'X': handler.on_loc_time(numeric_system::standard); break;
+      case 'D': handler.on_us_date(); break;
+      case 'F': handler.on_iso_date(); break;
+      case 'r': handler.on_12_hour_time(); break;
+      case 'R': handler.on_24_hour_time(); break;
+      case 'T': handler.on_iso_time(); break;
+      case 'p': handler.on_am_pm(); break;
+      case 'Q': handler.on_duration_value(); break;
+      case 'q': handler.on_duration_unit(); break;
+      case 'z': handler.on_utc_offset(); break;
+      case 'Z': handler.on_tz_name(); break;
+      // Alternative representation:
+      case 'E': {
+        if (ptr == end)
+          FMT_THROW(format_error("invalid format"));
+        c = *ptr++;
+        switch (c) {
+        case 'c': handler.on_datetime(numeric_system::alternative); break;
+        case 'x': handler.on_loc_date(numeric_system::alternative); break;
+        case 'X': handler.on_loc_time(numeric_system::alternative); break;
+        default: FMT_THROW(format_error("invalid format"));
+        }
         break;
-      case 'S':
-        handler.on_second(numeric_system::alternative);
+      }
+      case 'O':
+        if (ptr == end)
+          FMT_THROW(format_error("invalid format"));
+        c = *ptr++;
+        switch (c) {
+        case 'w': handler.on_dec0_weekday(numeric_system::alternative); break;
+        case 'u': handler.on_dec1_weekday(numeric_system::alternative); break;
+        case 'H': handler.on_24_hour(numeric_system::alternative); break;
+        case 'I': handler.on_12_hour(numeric_system::alternative); break;
+        case 'M': handler.on_minute(numeric_system::alternative); break;
+        case 'S': handler.on_second(numeric_system::alternative); break;
+        default: FMT_THROW(format_error("invalid format"));
+        }
         break;
-      default:
-        FMT_THROW(format_error("invalid format"));
+      default: FMT_THROW(format_error("invalid format"));
       }
-      break;
-    default:
-      FMT_THROW(format_error("invalid format"));
+      begin = ptr;
     }
-    begin = ptr;
+    if (begin != ptr)
+      handler.on_text(begin, ptr);
+    return ptr;
   }
-  if (begin != ptr) handler.on_text(begin, ptr);
-  return ptr;
-}
 
-struct chrono_format_checker {
-  FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
-
-  template <typename Char> void on_text(const Char*, const Char*) {}
-  FMT_NORETURN void on_abbr_weekday() { report_no_date(); }
-  FMT_NORETURN void on_full_weekday() { report_no_date(); }
-  FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_abbr_month() { report_no_date(); }
-  FMT_NORETURN void on_full_month() { report_no_date(); }
-  void on_24_hour(numeric_system) {}
-  void on_12_hour(numeric_system) {}
-  void on_minute(numeric_system) {}
-  void on_second(numeric_system) {}
-  FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_us_date() { report_no_date(); }
-  FMT_NORETURN void on_iso_date() { report_no_date(); }
-  void on_12_hour_time() {}
-  void on_24_hour_time() {}
-  void on_iso_time() {}
-  void on_am_pm() {}
-  void on_duration_value() {}
-  void on_duration_unit() {}
-  FMT_NORETURN void on_utc_offset() { report_no_date(); }
-  FMT_NORETURN void on_tz_name() { report_no_date(); }
-};
+  struct chrono_format_checker
+  {
+    FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
+
+    template <typename Char> void on_text(const Char *, const Char *) {}
+    FMT_NORETURN void             on_abbr_weekday() { report_no_date(); }
+    FMT_NORETURN void             on_full_weekday() { report_no_date(); }
+    FMT_NORETURN void             on_dec0_weekday(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_dec1_weekday(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_abbr_month() { report_no_date(); }
+    FMT_NORETURN void             on_full_month() { report_no_date(); }
+    void                          on_24_hour(numeric_system) {}
+    void                          on_12_hour(numeric_system) {}
+    void                          on_minute(numeric_system) {}
+    void                          on_second(numeric_system) {}
+    FMT_NORETURN void             on_datetime(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_loc_date(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_loc_time(numeric_system) { report_no_date(); }
+    FMT_NORETURN void             on_us_date() { report_no_date(); }
+    FMT_NORETURN void             on_iso_date() { report_no_date(); }
+    void                          on_12_hour_time() {}
+    void                          on_24_hour_time() {}
+    void                          on_iso_time() {}
+    void                          on_am_pm() {}
+    void                          on_duration_value() {}
+    void                          on_duration_unit() {}
+    FMT_NORETURN void             on_utc_offset() { report_no_date(); }
+    FMT_NORETURN void             on_tz_name() { report_no_date(); }
+  };
 
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline bool isnan(T) {
-  return false;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isnan(T value) {
-  return std::isnan(value);
-}
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline bool isnan(T)
+  {
+    return false;
+  }
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> inline bool isnan(T value)
+  {
+    return std::isnan(value);
+  }
 
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline bool isfinite(T) {
-  return true;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isfinite(T value) {
-  return std::isfinite(value);
-}
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline bool isfinite(T)
+  {
+    return true;
+  }
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  inline bool isfinite(T value)
+  {
+    return std::isfinite(value);
+  }
 
-// Convers value to int and checks that it's in the range [0, upper).
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline int to_nonnegative_int(T value, int upper) {
-  FMT_ASSERT(value >= 0 && value <= upper, "invalid value");
-  (void)upper;
-  return static_cast<int>(value);
-}
-template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-inline int to_nonnegative_int(T value, int upper) {
-  FMT_ASSERT(
-      std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
-      "invalid value");
-  (void)upper;
-  return static_cast<int>(value);
-}
+  // Converts value to int and checks that it's in the range [0, upper).
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  inline int to_nonnegative_int(T value, int upper)
+  {
+    FMT_ASSERT(value >= 0 && value <= upper, "invalid value");
+    (void)upper;
+    return static_cast<int>(value);
+  }
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  inline int to_nonnegative_int(T value, int upper)
+  {
+    FMT_ASSERT(std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
+               "invalid value");
+    (void)upper;
+    return static_cast<int>(value);
+  }
 
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline T mod(T x, int y) {
-  return x % y;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline T mod(T x, int y) {
-  return std::fmod(x, static_cast<T>(y));
-}
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline T mod(T x, int y)
+  {
+    return x % y;
+  }
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> inline T mod(T x, int y)
+  {
+    return std::fmod(x, static_cast<T>(y));
+  }
 
-// If T is an integral type, maps T to its unsigned counterpart, otherwise
-// leaves it unchanged (unlike std::make_unsigned).
-template <typename T, bool INTEGRAL = std::is_integral<T>::value>
-struct make_unsigned_or_unchanged {
-  using type = T;
-};
+  // If T is an integral type, maps T to its unsigned counterpart, otherwise
+  // leaves it unchanged (unlike std::make_unsigned).
+  template <typename T, bool INTEGRAL = std::is_integral<T>::value>
+  struct make_unsigned_or_unchanged
+  {
+    using type = T;
+  };
 
-template <typename T> struct make_unsigned_or_unchanged<T, true> {
-  using type = typename std::make_unsigned<T>::type;
-};
+  template <typename T> struct make_unsigned_or_unchanged<T, true>
+  {
+    using type = typename std::make_unsigned<T>::type;
+  };
 
 #if FMT_SAFE_DURATION_CAST
-// throwing version of safe_duration_cast
-template <typename To, typename FromRep, typename FromPeriod>
-To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) {
-  int ec;
-  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
-  if (ec) FMT_THROW(format_error("cannot format duration"));
-  return to;
-}
+  // throwing version of safe_duration_cast
+  template <typename To, typename FromRep, typename FromPeriod>
+  To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from)
+  {
+    int ec;
+    To  to = safe_duration_cast::safe_duration_cast<To>(from, ec);
+    if (ec)
+      FMT_THROW(format_error("cannot format duration"));
+    return to;
+  }
 #endif
 
-template <typename Rep, typename Period,
-          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
-inline std::chrono::duration<Rep, std::milli> get_milliseconds(
-    std::chrono::duration<Rep, Period> d) {
-  // this may overflow and/or the result may not fit in the
-  // target type.
+  template <typename Rep, typename Period, FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+  inline std::chrono::duration<Rep, std::milli>
+  get_milliseconds(std::chrono::duration<Rep, Period> d)
+  {
+    // this may overflow and/or the result may not fit in the
+    // target type.
 #if FMT_SAFE_DURATION_CAST
-  using CommonSecondsType =
-      typename std::common_type<decltype(d), std::chrono::seconds>::type;
-  const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
-  const auto d_as_whole_seconds =
-      fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
-  // this conversion should be nonproblematic
-  const auto diff = d_as_common - d_as_whole_seconds;
-  const auto ms =
-      fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
-  return ms;
+    using CommonSecondsType = typename std::common_type<decltype(d), std::chrono::seconds>::type;
+    const auto d_as_common  = fmt_safe_duration_cast<CommonSecondsType>(d);
+    const auto d_as_whole_seconds = fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
+    // this conversion should be nonproblematic
+    const auto diff = d_as_common - d_as_whole_seconds;
+    const auto ms   = fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+    return ms;
 #else
-  auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
-  return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
+    auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
+    return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
 #endif
-}
+  }
 
-template <typename Rep, typename Period,
-          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
-inline std::chrono::duration<Rep, std::milli> get_milliseconds(
-    std::chrono::duration<Rep, Period> d) {
-  using common_type = typename std::common_type<Rep, std::intmax_t>::type;
-  auto ms = mod(d.count() * static_cast<common_type>(Period::num) /
-                    static_cast<common_type>(Period::den) * 1000,
-                1000);
-  return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
-}
+  template <typename Rep, typename Period, FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
+  inline std::chrono::duration<Rep, std::milli>
+  get_milliseconds(std::chrono::duration<Rep, Period> d)
+  {
+    using common_type = typename std::common_type<Rep, std::intmax_t>::type;
+    auto ms           = mod(d.count() * static_cast<common_type>(Period::num) /
+                      static_cast<common_type>(Period::den) * 1000,
+                  1000);
+    return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
+  }
 
-template <typename Rep, typename OutputIt>
-OutputIt format_chrono_duration_value(OutputIt out, Rep val, int precision) {
-  if (precision >= 0) return format_to(out, "{:.{}f}", val, precision);
-  return format_to(out, std::is_floating_point<Rep>::value ? "{:g}" : "{}",
-                   val);
-}
+  template <typename Rep, typename OutputIt>
+  OutputIt format_chrono_duration_value(OutputIt out, Rep val, int precision)
+  {
+    if (precision >= 0)
+      return format_to(out, "{:.{}f}", val, precision);
+    return format_to(out, std::is_floating_point<Rep>::value ? "{:g}" : "{}", val);
+  }
 
-template <typename Period, typename OutputIt>
-static OutputIt format_chrono_duration_unit(OutputIt out) {
-  if (const char* unit = get_units<Period>()) return format_to(out, "{}", unit);
-  if (Period::den == 1) return format_to(out, "[{}]s", Period::num);
-  return format_to(out, "[{}/{}]s", Period::num, Period::den);
-}
+  template <typename Period, typename OutputIt>
+  static OutputIt format_chrono_duration_unit(OutputIt out)
+  {
+    if (const char *unit = get_units<Period>())
+      return format_to(out, "{}", unit);
+    if (Period::den == 1)
+      return format_to(out, "[{}]s", Period::num);
+    return format_to(out, "[{}/{}]s", Period::num, Period::den);
+  }
 
-template <typename FormatContext, typename OutputIt, typename Rep,
-          typename Period>
-struct chrono_formatter {
-  FormatContext& context;
-  OutputIt out;
-  int precision;
-  // rep is unsigned to avoid overflow.
-  using rep =
-      conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
-                    unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
-  rep val;
-  using seconds = std::chrono::duration<rep>;
-  seconds s;
-  using milliseconds = std::chrono::duration<rep, std::milli>;
-  bool negative;
-
-  using char_type = typename FormatContext::char_type;
-
-  explicit chrono_formatter(FormatContext& ctx, OutputIt o,
-                            std::chrono::duration<Rep, Period> d)
-      : context(ctx), out(o), val(d.count()), negative(false) {
-    if (d.count() < 0) {
-      val = 0 - val;
-      negative = true;
-    }
+  template <typename FormatContext, typename OutputIt, typename Rep, typename Period>
+  struct chrono_formatter
+  {
+    FormatContext &context;
+    OutputIt       out;
+    int            precision;
+    // rep is unsigned to avoid overflow.
+    using rep = conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int), unsigned,
+                              typename make_unsigned_or_unchanged<Rep>::type>;
+    rep val;
+    using seconds = std::chrono::duration<rep>;
+    seconds s;
+    using milliseconds = std::chrono::duration<rep, std::milli>;
+    bool negative;
+
+    using char_type = typename FormatContext::char_type;
+
+    explicit chrono_formatter(FormatContext &ctx, OutputIt o, std::chrono::duration<Rep, Period> d)
+        : context(ctx), out(o), val(d.count()), negative(false)
+    {
+      if (d.count() < 0) {
+        val      = 0 - val;
+        negative = true;
+      }
 
-    // this may overflow and/or the result may not fit in the
-    // target type.
+      // this may overflow and/or the result may not fit in the
+      // target type.
 #if FMT_SAFE_DURATION_CAST
-    // might need checked conversion (rep!=Rep)
-    auto tmpval = std::chrono::duration<rep, Period>(val);
-    s = fmt_safe_duration_cast<seconds>(tmpval);
+      // might need checked conversion (rep!=Rep)
+      auto tmpval = std::chrono::duration<rep, Period>(val);
+      s           = fmt_safe_duration_cast<seconds>(tmpval);
 #else
-    s = std::chrono::duration_cast<seconds>(
-        std::chrono::duration<rep, Period>(val));
+      s = std::chrono::duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
 #endif
-  }
-
-  // returns true if nan or inf, writes to out.
-  bool handle_nan_inf() {
-    if (isfinite(val)) {
-      return false;
     }
-    if (isnan(val)) {
-      write_nan();
+
+    // returns true if nan or inf, writes to out.
+    bool handle_nan_inf()
+    {
+      if (isfinite(val)) {
+        return false;
+      }
+      if (isnan(val)) {
+        write_nan();
+        return true;
+      }
+      // must be +-inf
+      if (val > 0) {
+        write_pinf();
+      }
+      else {
+        write_ninf();
+      }
       return true;
     }
-    // must be +-inf
-    if (val > 0) {
-      write_pinf();
-    } else {
-      write_ninf();
-    }
-    return true;
-  }
 
-  Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
+    Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
 
-  Rep hour12() const {
-    Rep my_hour = static_cast<Rep>(mod((s.count() / 3600), 12));
-    return my_hour <= 0 ? 12 : my_hour;
-  }
-
-  Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
-  Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
+    Rep hour12() const
+    {
+      Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
+      return hour <= 0 ? 12 : hour;
+    }
 
-  std::tm time() const {
-    auto my_time = std::tm();
-    my_time.tm_hour = to_nonnegative_int(hour(), 24);
-    my_time.tm_min = to_nonnegative_int(minute(), 60);
-    my_time.tm_sec = to_nonnegative_int(second(), 60);
-    return my_time;
-  }
+    Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
+    Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
 
-  void write_sign() {
-    if (negative) {
-      *out++ = '-';
-      negative = false;
+    std::tm time() const
+    {
+      auto time    = std::tm();
+      time.tm_hour = to_nonnegative_int(hour(), 24);
+      time.tm_min  = to_nonnegative_int(minute(), 60);
+      time.tm_sec  = to_nonnegative_int(second(), 60);
+      return time;
     }
-  }
 
-  void write(Rep value, int width) {
-    write_sign();
-    if (isnan(value)) return write_nan();
-    uint32_or_64_t<int> n = to_unsigned(
-        to_nonnegative_int(value, (std::numeric_limits<int>::max)()));
-    int num_digits = internal::count_digits(n);
-    if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
-    out = format_decimal<char_type>(out, n, num_digits);
-  }
+    void write_sign()
+    {
+      if (negative) {
+        *out++   = '-';
+        negative = false;
+      }
+    }
 
-  void write_nan() { std::copy_n("nan", 3, out); }
-  void write_pinf() { std::copy_n("inf", 3, out); }
-  void write_ninf() { std::copy_n("-inf", 4, out); }
-
-  void format_localized(const tm& my_time, const char* format) {
-    if (isnan(val)) return write_nan();
-    auto locale = context.locale().template get<std::locale>();
-    auto& facet = std::use_facet<std::time_put<char_type>>(locale);
-    std::basic_ostringstream<char_type> os;
-    os.imbue(locale);
-    facet.put(os, os, ' ', &my_time, format, format + std::strlen(format));
-    auto str = os.str();
-    std::copy(str.begin(), str.end(), out);
-  }
+    void write(Rep value, int width)
+    {
+      write_sign();
+      if (isnan(value))
+        return write_nan();
+      uint32_or_64_or_128_t<int> n = to_unsigned(to_nonnegative_int(value, max_value<int>()));
+      int                        num_digits = internal::count_digits(n);
+      if (width > num_digits)
+        out = std::fill_n(out, width - num_digits, '0');
+      out = format_decimal<char_type>(out, n, num_digits);
+    }
 
-  void on_text(const char_type* begin, const char_type* end) {
-    std::copy(begin, end, out);
-  }
+    void write_nan() { std::copy_n("nan", 3, out); }
+    void write_pinf() { std::copy_n("inf", 3, out); }
+    void write_ninf() { std::copy_n("-inf", 4, out); }
+
+    void format_localized(const tm &time, const char *format)
+    {
+      if (isnan(val))
+        return write_nan();
+      auto                                locale = context.locale().template get<std::locale>();
+      auto &                              facet  = std::use_facet<std::time_put<char_type>>(locale);
+      std::basic_ostringstream<char_type> os;
+      os.imbue(locale);
+      facet.put(os, os, ' ', &time, format, format + std::strlen(format));
+      auto str = os.str();
+      std::copy(str.begin(), str.end(), out);
+    }
 
-  // These are not implemented because durations don't have date information.
-  void on_abbr_weekday() {}
-  void on_full_weekday() {}
-  void on_dec0_weekday(numeric_system) {}
-  void on_dec1_weekday(numeric_system) {}
-  void on_abbr_month() {}
-  void on_full_month() {}
-  void on_datetime(numeric_system) {}
-  void on_loc_date(numeric_system) {}
-  void on_loc_time(numeric_system) {}
-  void on_us_date() {}
-  void on_iso_date() {}
-  void on_utc_offset() {}
-  void on_tz_name() {}
-
-  void on_24_hour(numeric_system ns) {
-    if (handle_nan_inf()) return;
-
-    if (ns == numeric_system::standard) return write(hour(), 2);
-    auto my_time = tm();
-    my_time.tm_hour = to_nonnegative_int(hour(), 24);
-    format_localized(my_time, "%OH");
-  }
+    void on_text(const char_type *begin, const char_type *end) { std::copy(begin, end, out); }
+
+    // These are not implemented because durations don't have date information.
+    void on_abbr_weekday() {}
+    void on_full_weekday() {}
+    void on_dec0_weekday(numeric_system) {}
+    void on_dec1_weekday(numeric_system) {}
+    void on_abbr_month() {}
+    void on_full_month() {}
+    void on_datetime(numeric_system) {}
+    void on_loc_date(numeric_system) {}
+    void on_loc_time(numeric_system) {}
+    void on_us_date() {}
+    void on_iso_date() {}
+    void on_utc_offset() {}
+    void on_tz_name() {}
+
+    void on_24_hour(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
+
+      if (ns == numeric_system::standard)
+        return write(hour(), 2);
+      auto time    = tm();
+      time.tm_hour = to_nonnegative_int(hour(), 24);
+      format_localized(time, "%OH");
+    }
 
-  void on_12_hour(numeric_system ns) {
-    if (handle_nan_inf()) return;
+    void on_12_hour(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
 
-    if (ns == numeric_system::standard) return write(hour12(), 2);
-    auto my_time = tm();
-    my_time.tm_hour = to_nonnegative_int(hour12(), 12);
-    format_localized(my_time, "%OI");
-  }
+      if (ns == numeric_system::standard)
+        return write(hour12(), 2);
+      auto time    = tm();
+      time.tm_hour = to_nonnegative_int(hour12(), 12);
+      format_localized(time, "%OI");
+    }
 
-  void on_minute(numeric_system ns) {
-    if (handle_nan_inf()) return;
+    void on_minute(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
 
-    if (ns == numeric_system::standard) return write(minute(), 2);
-    auto my_time = tm();
-    my_time.tm_min = to_nonnegative_int(minute(), 60);
-    format_localized(my_time, "%OM");
-  }
+      if (ns == numeric_system::standard)
+        return write(minute(), 2);
+      auto time   = tm();
+      time.tm_min = to_nonnegative_int(minute(), 60);
+      format_localized(time, "%OM");
+    }
 
-  void on_second(numeric_system ns) {
-    if (handle_nan_inf()) return;
+    void on_second(numeric_system ns)
+    {
+      if (handle_nan_inf())
+        return;
 
-    if (ns == numeric_system::standard) {
-      write(second(), 2);
+      if (ns == numeric_system::standard) {
+        write(second(), 2);
 #if FMT_SAFE_DURATION_CAST
-      // convert rep->Rep
-      using duration_rep = std::chrono::duration<rep, Period>;
-      using duration_Rep = std::chrono::duration<Rep, Period>;
-      auto tmpval = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
+        // convert rep->Rep
+        using duration_rep = std::chrono::duration<rep, Period>;
+        using duration_Rep = std::chrono::duration<Rep, Period>;
+        auto tmpval        = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
 #else
-      auto tmpval = std::chrono::duration<Rep, Period>(val);
+        auto tmpval = std::chrono::duration<Rep, Period>(val);
 #endif
-      auto ms = get_milliseconds(tmpval);
-      if (ms != std::chrono::milliseconds(0)) {
-        *out++ = '.';
-        write(ms.count(), 3);
+        auto ms = get_milliseconds(tmpval);
+        if (ms != std::chrono::milliseconds(0)) {
+          *out++ = '.';
+          write(ms.count(), 3);
+        }
+        return;
       }
-      return;
+      auto time   = tm();
+      time.tm_sec = to_nonnegative_int(second(), 60);
+      format_localized(time, "%OS");
     }
-    auto my_time = tm();
-    my_time.tm_sec = to_nonnegative_int(second(), 60);
-    format_localized(my_time, "%OS");
-  }
 
-  void on_12_hour_time() {
-    if (handle_nan_inf()) return;
+    void on_12_hour_time()
+    {
+      if (handle_nan_inf())
+        return;
 
-    format_localized(time(), "%r");
-  }
+      format_localized(time(), "%r");
+    }
 
-  void on_24_hour_time() {
-    if (handle_nan_inf()) {
+    void on_24_hour_time()
+    {
+      if (handle_nan_inf()) {
+        *out++ = ':';
+        handle_nan_inf();
+        return;
+      }
+
+      write(hour(), 2);
       *out++ = ':';
-      handle_nan_inf();
-      return;
+      write(minute(), 2);
     }
 
-    write(hour(), 2);
-    *out++ = ':';
-    write(minute(), 2);
-  }
-
-  void on_iso_time() {
-    on_24_hour_time();
-    *out++ = ':';
-    if (handle_nan_inf()) return;
-    write(second(), 2);
-  }
+    void on_iso_time()
+    {
+      on_24_hour_time();
+      *out++ = ':';
+      if (handle_nan_inf())
+        return;
+      write(second(), 2);
+    }
 
-  void on_am_pm() {
-    if (handle_nan_inf()) return;
-    format_localized(time(), "%p");
-  }
+    void on_am_pm()
+    {
+      if (handle_nan_inf())
+        return;
+      format_localized(time(), "%p");
+    }
 
-  void on_duration_value() {
-    if (handle_nan_inf()) return;
-    write_sign();
-    out = format_chrono_duration_value(out, val, precision);
-  }
+    void on_duration_value()
+    {
+      if (handle_nan_inf())
+        return;
+      write_sign();
+      out = format_chrono_duration_value(out, val, precision);
+    }
 
-  void on_duration_unit() { out = format_chrono_duration_unit<Period>(out); }
-};
-}  // namespace internal
+    void on_duration_unit() { out = format_chrono_duration_unit<Period>(out); }
+  };
+} // namespace internal
 
 template <typename Rep, typename Period, typename Char>
-struct formatter<std::chrono::duration<Rep, Period>, Char> {
- private:
+struct formatter<std::chrono::duration<Rep, Period>, Char>
+{
+private:
   basic_format_specs<Char> specs;
-  int precision;
+  int                      precision;
   using arg_ref_type = internal::arg_ref<Char>;
-  arg_ref_type width_ref;
-  arg_ref_type precision_ref;
+  arg_ref_type                    width_ref;
+  arg_ref_type                    precision_ref;
   mutable basic_string_view<Char> format_str;
   using duration = std::chrono::duration<Rep, Period>;
 
-  struct spec_handler {
-    formatter& f;
-    basic_parse_context<Char>& context;
-    basic_string_view<Char> format_str;
+  struct spec_handler
+  {
+    formatter &                f;
+    basic_parse_context<Char> &context;
+    basic_string_view<Char>    format_str;
 
-    template <typename Id> FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
+    template <typename Id> FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id)
+    {
       context.check_arg_id(arg_id);
       return arg_ref_type(arg_id);
     }
 
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id) {
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id)
+    {
       context.check_arg_id(arg_id);
-      const auto str_val = internal::string_view_metadata(format_str, arg_id);
-      return arg_ref_type(str_val);
+      return arg_ref_type(arg_id);
     }
 
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id) {
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id)
+    {
       return arg_ref_type(context.next_arg_id());
     }
 
-    void on_error(const char* msg) { FMT_THROW(format_error(msg)); }
+    void on_error(const char *msg) { FMT_THROW(format_error(msg)); }
     void on_fill(Char fill) { f.specs.fill[0] = fill; }
     void on_align(align_t align) { f.specs.align = align; }
     void on_width(unsigned width) { f.specs.width = width; }
-    void on_precision(unsigned precision) { f.precision = precision; }
+    void on_precision(unsigned _precision) { f.precision = _precision; }
     void end_precision() {}
 
-    template <typename Id> void on_dynamic_width(Id arg_id) {
-      f.width_ref = make_arg_ref(arg_id);
-    }
+    template <typename Id> void on_dynamic_width(Id arg_id) { f.width_ref = make_arg_ref(arg_id); }
 
-    template <typename Id> void on_dynamic_precision(Id arg_id) {
+    template <typename Id> void on_dynamic_precision(Id arg_id)
+    {
       f.precision_ref = make_arg_ref(arg_id);
     }
   };
 
   using iterator = typename basic_parse_context<Char>::iterator;
-  struct parse_range {
+  struct parse_range
+  {
     iterator begin;
     iterator end;
   };
 
-  FMT_CONSTEXPR parse_range do_parse(basic_parse_context<Char>& ctx) {
+  FMT_CONSTEXPR parse_range do_parse(basic_parse_context<Char> &ctx)
+  {
     auto begin = ctx.begin(), end = ctx.end();
-    if (begin == end || *begin == '}') return {begin, begin};
+    if (begin == end || *begin == '}')
+      return {begin, begin};
     spec_handler handler{*this, ctx, format_str};
     begin = internal::parse_align(begin, end, handler);
-    if (begin == end) return {begin, begin};
+    if (begin == end)
+      return {begin, begin};
     begin = internal::parse_width(begin, end, handler);
-    if (begin == end) return {begin, begin};
+    if (begin == end)
+      return {begin, begin};
     if (*begin == '.') {
       if (std::is_floating_point<Rep>::value)
         begin = internal::parse_precision(begin, end, handler);
@@ -786,36 +776,35 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     return {begin, end};
   }
 
- public:
+public:
   formatter() : precision(-1) {}
 
-  FMT_CONSTEXPR auto parse(basic_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(basic_parse_context<Char> &ctx) -> decltype(ctx.begin())
+  {
     auto range = do_parse(ctx);
-    format_str = basic_string_view<Char>(
-        &*range.begin, internal::to_unsigned(range.end - range.begin));
+    format_str =
+        basic_string_view<Char>(&*range.begin, internal::to_unsigned(range.end - range.begin));
     return range.end;
   }
 
   template <typename FormatContext>
-  auto format(const duration& d, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const duration &d, FormatContext &ctx) -> decltype(ctx.out())
+  {
     auto begin = format_str.begin(), end = format_str.end();
     // As a possible future optimization, we could avoid extra copying if width
     // is not specified.
     basic_memory_buffer<Char> buf;
-    auto out = std::back_inserter(buf);
-    using range = internal::output_range<decltype(ctx.out()), Char>;
+    auto                      out = std::back_inserter(buf);
+    using range                   = internal::output_range<decltype(ctx.out()), Char>;
     internal::basic_writer<range> w(range(ctx.out()));
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs.width, width_ref, ctx, format_str.begin());
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        precision, precision_ref, ctx, format_str.begin());
+    internal::handle_dynamic_spec<internal::width_checker>(specs.width, width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(precision, precision_ref, ctx);
     if (begin == end || *begin == '}') {
       out = internal::format_chrono_duration_value(out, d.count(), precision);
       internal::format_chrono_duration_unit<Period>(out);
-    } else {
-      internal::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
-          ctx, out, d);
+    }
+    else {
+      internal::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(ctx, out, d);
       f.precision = precision;
       parse_chrono_format(begin, end, f);
     }
@@ -826,4 +815,4 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
 
 FMT_END_NAMESPACE
 
-#endif  // FMT_CHRONO_H_
+#endif // FMT_CHRONO_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/color.h b/packages/seacas/libraries/suplib_cpp/fmt/color.h
index d9d315599f01..72f99617b99f 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/color.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/color.h
@@ -13,148 +13,148 @@
 FMT_BEGIN_NAMESPACE
 
 enum class color : uint32_t {
-  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
-  antique_white = 0xFAEBD7,            // rgb(250,235,215)
-  aqua = 0x00FFFF,                     // rgb(0,255,255)
-  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
-  azure = 0xF0FFFF,                    // rgb(240,255,255)
-  beige = 0xF5F5DC,                    // rgb(245,245,220)
-  bisque = 0xFFE4C4,                   // rgb(255,228,196)
-  black = 0x000000,                    // rgb(0,0,0)
-  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
-  blue = 0x0000FF,                     // rgb(0,0,255)
-  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
-  brown = 0xA52A2A,                    // rgb(165,42,42)
-  burly_wood = 0xDEB887,               // rgb(222,184,135)
-  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
-  chartreuse = 0x7FFF00,               // rgb(127,255,0)
-  chocolate = 0xD2691E,                // rgb(210,105,30)
-  coral = 0xFF7F50,                    // rgb(255,127,80)
-  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
-  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
-  crimson = 0xDC143C,                  // rgb(220,20,60)
-  cyan = 0x00FFFF,                     // rgb(0,255,255)
-  dark_blue = 0x00008B,                // rgb(0,0,139)
-  dark_cyan = 0x008B8B,                // rgb(0,139,139)
-  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
-  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
-  dark_green = 0x006400,               // rgb(0,100,0)
-  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
-  dark_magenta = 0x8B008B,             // rgb(139,0,139)
-  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
-  dark_orange = 0xFF8C00,              // rgb(255,140,0)
-  dark_orchid = 0x9932CC,              // rgb(153,50,204)
-  dark_red = 0x8B0000,                 // rgb(139,0,0)
-  dark_salmon = 0xE9967A,              // rgb(233,150,122)
-  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
-  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
-  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
-  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
-  dark_violet = 0x9400D3,              // rgb(148,0,211)
-  deep_pink = 0xFF1493,                // rgb(255,20,147)
-  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
-  dim_gray = 0x696969,                 // rgb(105,105,105)
-  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
-  fire_brick = 0xB22222,               // rgb(178,34,34)
-  floral_white = 0xFFFAF0,             // rgb(255,250,240)
-  forest_green = 0x228B22,             // rgb(34,139,34)
-  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
-  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
-  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
-  gold = 0xFFD700,                     // rgb(255,215,0)
-  golden_rod = 0xDAA520,               // rgb(218,165,32)
-  gray = 0x808080,                     // rgb(128,128,128)
-  green = 0x008000,                    // rgb(0,128,0)
-  green_yellow = 0xADFF2F,             // rgb(173,255,47)
-  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
-  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
-  indian_red = 0xCD5C5C,               // rgb(205,92,92)
-  indigo = 0x4B0082,                   // rgb(75,0,130)
-  ivory = 0xFFFFF0,                    // rgb(255,255,240)
-  khaki = 0xF0E68C,                    // rgb(240,230,140)
-  lavender = 0xE6E6FA,                 // rgb(230,230,250)
-  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
-  lawn_green = 0x7CFC00,               // rgb(124,252,0)
-  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
-  light_blue = 0xADD8E6,               // rgb(173,216,230)
-  light_coral = 0xF08080,              // rgb(240,128,128)
-  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
-  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
-  light_gray = 0xD3D3D3,               // rgb(211,211,211)
-  light_green = 0x90EE90,              // rgb(144,238,144)
-  light_pink = 0xFFB6C1,               // rgb(255,182,193)
-  light_salmon = 0xFFA07A,             // rgb(255,160,122)
-  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
-  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
-  light_slate_gray = 0x778899,         // rgb(119,136,153)
-  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
-  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
-  lime = 0x00FF00,                     // rgb(0,255,0)
-  lime_green = 0x32CD32,               // rgb(50,205,50)
-  linen = 0xFAF0E6,                    // rgb(250,240,230)
-  magenta = 0xFF00FF,                  // rgb(255,0,255)
-  maroon = 0x800000,                   // rgb(128,0,0)
-  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
-  medium_blue = 0x0000CD,              // rgb(0,0,205)
-  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
-  medium_purple = 0x9370DB,            // rgb(147,112,219)
-  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
-  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
-  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
-  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
-  medium_violet_red = 0xC71585,        // rgb(199,21,133)
-  midnight_blue = 0x191970,            // rgb(25,25,112)
-  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
-  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
-  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
-  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
-  navy = 0x000080,                     // rgb(0,0,128)
-  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
-  olive = 0x808000,                    // rgb(128,128,0)
-  olive_drab = 0x6B8E23,               // rgb(107,142,35)
-  orange = 0xFFA500,                   // rgb(255,165,0)
-  orange_red = 0xFF4500,               // rgb(255,69,0)
-  orchid = 0xDA70D6,                   // rgb(218,112,214)
-  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
-  pale_green = 0x98FB98,               // rgb(152,251,152)
-  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
-  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
-  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
-  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
-  peru = 0xCD853F,                     // rgb(205,133,63)
-  pink = 0xFFC0CB,                     // rgb(255,192,203)
-  plum = 0xDDA0DD,                     // rgb(221,160,221)
-  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
-  purple = 0x800080,                   // rgb(128,0,128)
-  rebecca_purple = 0x663399,           // rgb(102,51,153)
-  red = 0xFF0000,                      // rgb(255,0,0)
-  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
-  royal_blue = 0x4169E1,               // rgb(65,105,225)
-  saddle_brown = 0x8B4513,             // rgb(139,69,19)
-  salmon = 0xFA8072,                   // rgb(250,128,114)
-  sandy_brown = 0xF4A460,              // rgb(244,164,96)
-  sea_green = 0x2E8B57,                // rgb(46,139,87)
-  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
-  sienna = 0xA0522D,                   // rgb(160,82,45)
-  silver = 0xC0C0C0,                   // rgb(192,192,192)
-  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
-  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
-  slate_gray = 0x708090,               // rgb(112,128,144)
-  snow = 0xFFFAFA,                     // rgb(255,250,250)
-  spring_green = 0x00FF7F,             // rgb(0,255,127)
-  steel_blue = 0x4682B4,               // rgb(70,130,180)
-  tan = 0xD2B48C,                      // rgb(210,180,140)
-  teal = 0x008080,                     // rgb(0,128,128)
-  thistle = 0xD8BFD8,                  // rgb(216,191,216)
-  tomato = 0xFF6347,                   // rgb(255,99,71)
-  turquoise = 0x40E0D0,                // rgb(64,224,208)
-  violet = 0xEE82EE,                   // rgb(238,130,238)
-  wheat = 0xF5DEB3,                    // rgb(245,222,179)
-  white = 0xFFFFFF,                    // rgb(255,255,255)
-  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
-  yellow = 0xFFFF00,                   // rgb(255,255,0)
-  yellow_green = 0x9ACD32              // rgb(154,205,50)
-};                                     // enum class color
+  alice_blue              = 0xF0F8FF, // rgb(240,248,255)
+  antique_white           = 0xFAEBD7, // rgb(250,235,215)
+  aqua                    = 0x00FFFF, // rgb(0,255,255)
+  aquamarine              = 0x7FFFD4, // rgb(127,255,212)
+  azure                   = 0xF0FFFF, // rgb(240,255,255)
+  beige                   = 0xF5F5DC, // rgb(245,245,220)
+  bisque                  = 0xFFE4C4, // rgb(255,228,196)
+  black                   = 0x000000, // rgb(0,0,0)
+  blanched_almond         = 0xFFEBCD, // rgb(255,235,205)
+  blue                    = 0x0000FF, // rgb(0,0,255)
+  blue_violet             = 0x8A2BE2, // rgb(138,43,226)
+  brown                   = 0xA52A2A, // rgb(165,42,42)
+  burly_wood              = 0xDEB887, // rgb(222,184,135)
+  cadet_blue              = 0x5F9EA0, // rgb(95,158,160)
+  chartreuse              = 0x7FFF00, // rgb(127,255,0)
+  chocolate               = 0xD2691E, // rgb(210,105,30)
+  coral                   = 0xFF7F50, // rgb(255,127,80)
+  cornflower_blue         = 0x6495ED, // rgb(100,149,237)
+  cornsilk                = 0xFFF8DC, // rgb(255,248,220)
+  crimson                 = 0xDC143C, // rgb(220,20,60)
+  cyan                    = 0x00FFFF, // rgb(0,255,255)
+  dark_blue               = 0x00008B, // rgb(0,0,139)
+  dark_cyan               = 0x008B8B, // rgb(0,139,139)
+  dark_golden_rod         = 0xB8860B, // rgb(184,134,11)
+  dark_gray               = 0xA9A9A9, // rgb(169,169,169)
+  dark_green              = 0x006400, // rgb(0,100,0)
+  dark_khaki              = 0xBDB76B, // rgb(189,183,107)
+  dark_magenta            = 0x8B008B, // rgb(139,0,139)
+  dark_olive_green        = 0x556B2F, // rgb(85,107,47)
+  dark_orange             = 0xFF8C00, // rgb(255,140,0)
+  dark_orchid             = 0x9932CC, // rgb(153,50,204)
+  dark_red                = 0x8B0000, // rgb(139,0,0)
+  dark_salmon             = 0xE9967A, // rgb(233,150,122)
+  dark_sea_green          = 0x8FBC8F, // rgb(143,188,143)
+  dark_slate_blue         = 0x483D8B, // rgb(72,61,139)
+  dark_slate_gray         = 0x2F4F4F, // rgb(47,79,79)
+  dark_turquoise          = 0x00CED1, // rgb(0,206,209)
+  dark_violet             = 0x9400D3, // rgb(148,0,211)
+  deep_pink               = 0xFF1493, // rgb(255,20,147)
+  deep_sky_blue           = 0x00BFFF, // rgb(0,191,255)
+  dim_gray                = 0x696969, // rgb(105,105,105)
+  dodger_blue             = 0x1E90FF, // rgb(30,144,255)
+  fire_brick              = 0xB22222, // rgb(178,34,34)
+  floral_white            = 0xFFFAF0, // rgb(255,250,240)
+  forest_green            = 0x228B22, // rgb(34,139,34)
+  fuchsia                 = 0xFF00FF, // rgb(255,0,255)
+  gainsboro               = 0xDCDCDC, // rgb(220,220,220)
+  ghost_white             = 0xF8F8FF, // rgb(248,248,255)
+  gold                    = 0xFFD700, // rgb(255,215,0)
+  golden_rod              = 0xDAA520, // rgb(218,165,32)
+  gray                    = 0x808080, // rgb(128,128,128)
+  green                   = 0x008000, // rgb(0,128,0)
+  green_yellow            = 0xADFF2F, // rgb(173,255,47)
+  honey_dew               = 0xF0FFF0, // rgb(240,255,240)
+  hot_pink                = 0xFF69B4, // rgb(255,105,180)
+  indian_red              = 0xCD5C5C, // rgb(205,92,92)
+  indigo                  = 0x4B0082, // rgb(75,0,130)
+  ivory                   = 0xFFFFF0, // rgb(255,255,240)
+  khaki                   = 0xF0E68C, // rgb(240,230,140)
+  lavender                = 0xE6E6FA, // rgb(230,230,250)
+  lavender_blush          = 0xFFF0F5, // rgb(255,240,245)
+  lawn_green              = 0x7CFC00, // rgb(124,252,0)
+  lemon_chiffon           = 0xFFFACD, // rgb(255,250,205)
+  light_blue              = 0xADD8E6, // rgb(173,216,230)
+  light_coral             = 0xF08080, // rgb(240,128,128)
+  light_cyan              = 0xE0FFFF, // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
+  light_gray              = 0xD3D3D3, // rgb(211,211,211)
+  light_green             = 0x90EE90, // rgb(144,238,144)
+  light_pink              = 0xFFB6C1, // rgb(255,182,193)
+  light_salmon            = 0xFFA07A, // rgb(255,160,122)
+  light_sea_green         = 0x20B2AA, // rgb(32,178,170)
+  light_sky_blue          = 0x87CEFA, // rgb(135,206,250)
+  light_slate_gray        = 0x778899, // rgb(119,136,153)
+  light_steel_blue        = 0xB0C4DE, // rgb(176,196,222)
+  light_yellow            = 0xFFFFE0, // rgb(255,255,224)
+  lime                    = 0x00FF00, // rgb(0,255,0)
+  lime_green              = 0x32CD32, // rgb(50,205,50)
+  linen                   = 0xFAF0E6, // rgb(250,240,230)
+  magenta                 = 0xFF00FF, // rgb(255,0,255)
+  maroon                  = 0x800000, // rgb(128,0,0)
+  medium_aquamarine       = 0x66CDAA, // rgb(102,205,170)
+  medium_blue             = 0x0000CD, // rgb(0,0,205)
+  medium_orchid           = 0xBA55D3, // rgb(186,85,211)
+  medium_purple           = 0x9370DB, // rgb(147,112,219)
+  medium_sea_green        = 0x3CB371, // rgb(60,179,113)
+  medium_slate_blue       = 0x7B68EE, // rgb(123,104,238)
+  medium_spring_green     = 0x00FA9A, // rgb(0,250,154)
+  medium_turquoise        = 0x48D1CC, // rgb(72,209,204)
+  medium_violet_red       = 0xC71585, // rgb(199,21,133)
+  midnight_blue           = 0x191970, // rgb(25,25,112)
+  mint_cream              = 0xF5FFFA, // rgb(245,255,250)
+  misty_rose              = 0xFFE4E1, // rgb(255,228,225)
+  moccasin                = 0xFFE4B5, // rgb(255,228,181)
+  navajo_white            = 0xFFDEAD, // rgb(255,222,173)
+  navy                    = 0x000080, // rgb(0,0,128)
+  old_lace                = 0xFDF5E6, // rgb(253,245,230)
+  olive                   = 0x808000, // rgb(128,128,0)
+  olive_drab              = 0x6B8E23, // rgb(107,142,35)
+  orange                  = 0xFFA500, // rgb(255,165,0)
+  orange_red              = 0xFF4500, // rgb(255,69,0)
+  orchid                  = 0xDA70D6, // rgb(218,112,214)
+  pale_golden_rod         = 0xEEE8AA, // rgb(238,232,170)
+  pale_green              = 0x98FB98, // rgb(152,251,152)
+  pale_turquoise          = 0xAFEEEE, // rgb(175,238,238)
+  pale_violet_red         = 0xDB7093, // rgb(219,112,147)
+  papaya_whip             = 0xFFEFD5, // rgb(255,239,213)
+  peach_puff              = 0xFFDAB9, // rgb(255,218,185)
+  peru                    = 0xCD853F, // rgb(205,133,63)
+  pink                    = 0xFFC0CB, // rgb(255,192,203)
+  plum                    = 0xDDA0DD, // rgb(221,160,221)
+  powder_blue             = 0xB0E0E6, // rgb(176,224,230)
+  purple                  = 0x800080, // rgb(128,0,128)
+  rebecca_purple          = 0x663399, // rgb(102,51,153)
+  red                     = 0xFF0000, // rgb(255,0,0)
+  rosy_brown              = 0xBC8F8F, // rgb(188,143,143)
+  royal_blue              = 0x4169E1, // rgb(65,105,225)
+  saddle_brown            = 0x8B4513, // rgb(139,69,19)
+  salmon                  = 0xFA8072, // rgb(250,128,114)
+  sandy_brown             = 0xF4A460, // rgb(244,164,96)
+  sea_green               = 0x2E8B57, // rgb(46,139,87)
+  sea_shell               = 0xFFF5EE, // rgb(255,245,238)
+  sienna                  = 0xA0522D, // rgb(160,82,45)
+  silver                  = 0xC0C0C0, // rgb(192,192,192)
+  sky_blue                = 0x87CEEB, // rgb(135,206,235)
+  slate_blue              = 0x6A5ACD, // rgb(106,90,205)
+  slate_gray              = 0x708090, // rgb(112,128,144)
+  snow                    = 0xFFFAFA, // rgb(255,250,250)
+  spring_green            = 0x00FF7F, // rgb(0,255,127)
+  steel_blue              = 0x4682B4, // rgb(70,130,180)
+  tan                     = 0xD2B48C, // rgb(210,180,140)
+  teal                    = 0x008080, // rgb(0,128,128)
+  thistle                 = 0xD8BFD8, // rgb(216,191,216)
+  tomato                  = 0xFF6347, // rgb(255,99,71)
+  turquoise               = 0x40E0D0, // rgb(64,224,208)
+  violet                  = 0xEE82EE, // rgb(238,130,238)
+  wheat                   = 0xF5DEB3, // rgb(245,222,179)
+  white                   = 0xFFFFFF, // rgb(255,255,255)
+  white_smoke             = 0xF5F5F5, // rgb(245,245,245)
+  yellow                  = 0xFFFF00, // rgb(255,255,0)
+  yellow_green            = 0x9ACD32  // rgb(154,205,50)
+};                                    // enum class color
 
 enum class terminal_color : uint8_t {
   black = 30,
@@ -176,23 +176,23 @@ enum class terminal_color : uint8_t {
 };
 
 enum class emphasis : uint8_t {
-  bold = 1,
-  italic = 1 << 1,
-  underline = 1 << 2,
+  bold          = 1,
+  italic        = 1 << 1,
+  underline     = 1 << 2,
   strikethrough = 1 << 3
 };
 
 // rgb is a struct for red, green and blue colors.
 // Using the name "rgb" makes some editors show the color in a tooltip.
-struct rgb {
+struct rgb
+{
   FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
   FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
-  FMT_CONSTEXPR rgb(uint32_t hex)
-      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(uint32_t hex) : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
   FMT_CONSTEXPR rgb(color hex)
-      : r((uint32_t(hex) >> 16) & 0xFF),
-        g((uint32_t(hex) >> 8) & 0xFF),
-        b(uint32_t(hex) & 0xFF) {}
+      : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), b(uint32_t(hex) & 0xFF)
+  {
+  }
   uint8_t r;
   uint8_t g;
   uint8_t b;
@@ -200,42 +200,48 @@ struct rgb {
 
 namespace internal {
 
-// color is a struct of either a rgb color or a terminal color.
-struct color_type {
-  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
-  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
-                                                           value{} {
-    value.rgb_color = static_cast<uint32_t>(rgb_color);
-  }
-  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
-    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
-                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
-  }
-  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
-                                                                     value{} {
-    value.term_color = static_cast<uint8_t>(term_color);
-  }
-  bool is_rgb;
-  union color_union {
-    uint8_t term_color;
-    uint32_t rgb_color;
-  } value;
-};
-}  // namespace internal
+  // color is a struct of either a rgb color or a terminal color.
+  struct color_type
+  {
+    FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+    FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true), value{}
+    {
+      value.rgb_color = static_cast<uint32_t>(rgb_color);
+    }
+    FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{}
+    {
+      value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                        (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+    }
+    FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(), value{}
+    {
+      value.term_color = static_cast<uint8_t>(term_color);
+    }
+    bool is_rgb;
+    union color_union {
+      uint8_t  term_color;
+      uint32_t rgb_color;
+    } value;
+  };
+} // namespace internal
 
 // Experimental text formatting support.
-class text_style {
- public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
-      : set_foreground_color(),
-        set_background_color(),
-        ems(em) {}
+class text_style
+{
+public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT : set_foreground_color(),
+                                                                    set_background_color(),
+                                                                    ems(em)
+  {
+  }
 
-  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+  FMT_CONSTEXPR text_style &operator|=(const text_style &rhs)
+  {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
+      foreground_color     = rhs.foreground_color;
+    }
+    else if (rhs.set_foreground_color) {
       if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
         FMT_THROW(format_error("can't OR a terminal color"));
       foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
@@ -243,28 +249,30 @@ class text_style {
 
     if (!set_background_color) {
       set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
+      background_color     = rhs.background_color;
+    }
+    else if (rhs.set_background_color) {
       if (!background_color.is_rgb || !rhs.background_color.is_rgb)
         FMT_THROW(format_error("can't OR a terminal color"));
       background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
     }
 
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
-                                static_cast<uint8_t>(rhs.ems));
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) | static_cast<uint8_t>(rhs.ems));
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
-                                            const text_style& rhs) {
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs, const text_style &rhs)
+  {
     return lhs |= rhs;
   }
 
-  FMT_CONSTEXPR text_style& operator&=(const text_style& rhs) {
+  FMT_CONSTEXPR text_style &operator&=(const text_style &rhs)
+  {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
+      foreground_color     = rhs.foreground_color;
+    }
+    else if (rhs.set_foreground_color) {
       if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
         FMT_THROW(format_error("can't AND a terminal color"));
       foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
@@ -272,256 +280,247 @@ class text_style {
 
     if (!set_background_color) {
       set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
+      background_color     = rhs.background_color;
+    }
+    else if (rhs.set_background_color) {
       if (!background_color.is_rgb || !rhs.background_color.is_rgb)
         FMT_THROW(format_error("can't AND a terminal color"));
       background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
     }
 
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
-                                static_cast<uint8_t>(rhs.ems));
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) & static_cast<uint8_t>(rhs.ems));
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator&(text_style lhs,
-                                            const text_style& rhs) {
+  friend FMT_CONSTEXPR text_style operator&(text_style lhs, const text_style &rhs)
+  {
     return lhs &= rhs;
   }
 
-  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
-    return set_foreground_color;
-  }
-  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
-    return set_background_color;
-  }
-  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
-    return static_cast<uint8_t>(ems) != 0;
-  }
-  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT { return set_foreground_color; }
+  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT { return set_background_color; }
+  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT { return static_cast<uint8_t>(ems) != 0; }
+  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT
+  {
     assert(has_foreground() && "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT
+  {
     assert(has_background() && "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT
+  {
     assert(has_emphasis() && "no emphasis specified for this style");
     return ems;
   }
 
- private:
-  FMT_CONSTEXPR text_style(bool is_foreground,
-                           internal::color_type text_color) FMT_NOEXCEPT
+private:
+  FMT_CONSTEXPR text_style(bool is_foreground, internal::color_type text_color) FMT_NOEXCEPT
       : set_foreground_color(),
         set_background_color(),
-        ems() {
+        ems()
+  {
     if (is_foreground) {
-      foreground_color = text_color;
+      foreground_color     = text_color;
       set_foreground_color = true;
-    } else {
-      background_color = text_color;
+    }
+    else {
+      background_color     = text_color;
       set_background_color = true;
     }
   }
 
-  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
-      FMT_NOEXCEPT;
-  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background)
-      FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground) FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background) FMT_NOEXCEPT;
 
   internal::color_type foreground_color;
   internal::color_type background_color;
-  bool set_foreground_color;
-  bool set_background_color;
-  emphasis ems;
+  bool                 set_foreground_color;
+  bool                 set_background_color;
+  emphasis             ems;
 };
 
-FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT {
+FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT
+{
   return text_style(/*is_foreground=*/true, foreground);
 }
 
-FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT {
+FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT
+{
   return text_style(/*is_foreground=*/false, background);
 }
 
-FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
+FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT
+{
   return text_style(lhs) | rhs;
 }
 
 namespace internal {
 
-template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
-                                  const char* esc) FMT_NOEXCEPT {
-    // If we have a terminal color, we need to output another escape code
-    // sequence.
-    if (!text_color.is_rgb) {
-      bool is_background = esc == internal::data::background_color;
-      uint32_t value = text_color.value.term_color;
-      // Background ASCII codes are the same as the foreground ones but with
-      // 10 more.
-      if (is_background) value += 10u;
-
-      std::size_t index = 0;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-
-      if (value >= 100u) {
-        buffer[index++] = static_cast<Char>('1');
-        value %= 100u;
+  template <typename Char> struct ansi_color_escape
+  {
+    FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color, const char *esc) FMT_NOEXCEPT
+    {
+      // If we have a terminal color, we need to output another escape code
+      // sequence.
+      if (!text_color.is_rgb) {
+        bool     is_background = esc == internal::data::background_color;
+        uint32_t value         = text_color.value.term_color;
+        // Background ASCII codes are the same as the foreground ones but with
+        // 10 more.
+        if (is_background)
+          value += 10u;
+
+        std::size_t index = 0;
+        buffer[index++]   = static_cast<Char>('\x1b');
+        buffer[index++]   = static_cast<Char>('[');
+
+        if (value >= 100u) {
+          buffer[index++] = static_cast<Char>('1');
+          value %= 100u;
+        }
+        buffer[index++] = static_cast<Char>('0' + value / 10u);
+        buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+        buffer[index++] = static_cast<Char>('m');
+        buffer[index++] = static_cast<Char>('\0');
+        return;
       }
-      buffer[index++] = static_cast<Char>('0' + value / 10u);
-      buffer[index++] = static_cast<Char>('0' + value % 10u);
 
-      buffer[index++] = static_cast<Char>('m');
-      buffer[index++] = static_cast<Char>('\0');
-      return;
+      for (int i = 0; i < 7; i++) {
+        buffer[i] = static_cast<Char>(esc[i]);
+      }
+      rgb color(text_color.value.rgb_color);
+      to_esc(color.r, buffer + 7, ';');
+      to_esc(color.g, buffer + 11, ';');
+      to_esc(color.b, buffer + 15, 'm');
+      buffer[19] = static_cast<Char>(0);
     }
+    FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT
+    {
+      uint8_t em_codes[4] = {};
+      uint8_t em_bits     = static_cast<uint8_t>(em);
+      if (em_bits & static_cast<uint8_t>(emphasis::bold))
+        em_codes[0] = 1;
+      if (em_bits & static_cast<uint8_t>(emphasis::italic))
+        em_codes[1] = 3;
+      if (em_bits & static_cast<uint8_t>(emphasis::underline))
+        em_codes[2] = 4;
+      if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+        em_codes[3] = 9;
 
-    for (int i = 0; i < 7; i++) {
-      buffer[i] = static_cast<Char>(esc[i]);
-    }
-    rgb color(text_color.value.rgb_color);
-    to_esc(color.r, buffer + 7, ';');
-    to_esc(color.g, buffer + 11, ';');
-    to_esc(color.b, buffer + 15, 'm');
-    buffer[19] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
-    uint8_t em_codes[4] = {};
-    uint8_t em_bits = static_cast<uint8_t>(em);
-    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
-    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
-    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
-      em_codes[3] = 9;
-
-    std::size_t index = 0;
-    for (int i = 0; i < 4; ++i) {
-      if (!em_codes[i]) continue;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
-      buffer[index++] = static_cast<Char>('m');
+      std::size_t index = 0;
+      for (int i = 0; i < 4; ++i) {
+        if (!em_codes[i])
+          continue;
+        buffer[index++] = static_cast<Char>('\x1b');
+        buffer[index++] = static_cast<Char>('[');
+        buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+        buffer[index++] = static_cast<Char>('m');
+      }
+      buffer[index++] = static_cast<Char>(0);
     }
-    buffer[index++] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
-
-  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
-  FMT_CONSTEXPR const Char* end() const FMT_NOEXCEPT {
-    return buffer + std::strlen(buffer);
-  }
+    FMT_CONSTEXPR operator const Char *() const FMT_NOEXCEPT { return buffer; }
 
- private:
-  Char buffer[7u + 3u * 4u + 1u];
+    FMT_CONSTEXPR const Char *begin() const FMT_NOEXCEPT { return buffer; }
+    FMT_CONSTEXPR const Char *end() const FMT_NOEXCEPT { return buffer + std::strlen(buffer); }
 
-  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) FMT_NOEXCEPT {
-    out[0] = static_cast<Char>('0' + c / 100);
-    out[1] = static_cast<Char>('0' + c / 10 % 10);
-    out[2] = static_cast<Char>('0' + c % 10);
-    out[3] = static_cast<Char>(delimiter);
-  }
-};
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    internal::color_type foreground) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(foreground, internal::data::foreground_color);
-}
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-    internal::color_type background) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(background, internal::data::background_color);
-}
-
-template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(em);
-}
+  private:
+    Char buffer[7u + 3u * 4u + 1u];
 
-template <typename Char>
-inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputs(chars, stream);
-}
-
-template <>
-inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputws(chars, stream);
-}
-
-template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
-  fputs(internal::data::reset_color, stream);
-}
-
-template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
-  fputs(internal::data::wreset_color, stream);
-}
+    static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out, char delimiter) FMT_NOEXCEPT
+    {
+      out[0] = static_cast<Char>('0' + c / 100);
+      out[1] = static_cast<Char>('0' + c / 10 % 10);
+      out[2] = static_cast<Char>('0' + c % 10);
+      out[3] = static_cast<Char>(delimiter);
+    }
+  };
 
-template <typename Char>
-inline void reset_color(basic_memory_buffer<Char>& buffer) FMT_NOEXCEPT {
-  const char* begin = data::reset_color;
-  const char* end = begin + sizeof(data::reset_color) - 1;
-  buffer.append(begin, end);
-}
+  template <typename Char>
+  FMT_CONSTEXPR ansi_color_escape<Char>
+                make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT
+  {
+    return ansi_color_escape<Char>(foreground, internal::data::foreground_color);
+  }
 
-template <typename Char>
-std::basic_string<Char> vformat(const text_style& ts,
-                                basic_string_view<Char> format_str,
-                                basic_format_args<buffer_context<Char> > args) {
-  basic_memory_buffer<Char> buffer;
-  bool has_style = false;
-  if (ts.has_emphasis()) {
-    has_style = true;
-    ansi_color_escape<Char> escape = make_emphasis<Char>(ts.get_emphasis());
-    buffer.append(escape.begin(), escape.end());
+  template <typename Char>
+  FMT_CONSTEXPR ansi_color_escape<Char>
+                make_background_color(internal::color_type background) FMT_NOEXCEPT
+  {
+    return ansi_color_escape<Char>(background, internal::data::background_color);
   }
-  if (ts.has_foreground()) {
-    has_style = true;
-    ansi_color_escape<Char> escape =
-        make_foreground_color<Char>(ts.get_foreground());
-    buffer.append(escape.begin(), escape.end());
+
+  template <typename Char>
+  FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT
+  {
+    return ansi_color_escape<Char>(em);
   }
-  if (ts.has_background()) {
-    has_style = true;
-    ansi_color_escape<Char> escape =
-        make_background_color<Char>(ts.get_background());
-    buffer.append(escape.begin(), escape.end());
+
+  template <typename Char> inline void fputs(const Char *chars, FILE *stream) FMT_NOEXCEPT
+  {
+    std::fputs(chars, stream);
   }
-  internal::vformat_to(buffer, format_str, args);
-  if (has_style) {
-    reset_color<Char>(buffer);
+
+  template <> inline void fputs<wchar_t>(const wchar_t *chars, FILE *stream) FMT_NOEXCEPT
+  {
+    std::fputws(chars, stream);
   }
-  return fmt::to_string(buffer);
-}
-}  // namespace internal
-
-template <typename S, typename Char = char_t<S> >
-void vprint(std::FILE* f, const text_style& ts, const S& format,
-            basic_format_args<buffer_context<Char> > args) {
-  bool has_style = false;
-  if (ts.has_emphasis()) {
-    has_style = true;
-    internal::fputs<Char>(internal::make_emphasis<Char>(ts.get_emphasis()), f);
+
+  template <typename Char> inline void reset_color(FILE *stream) FMT_NOEXCEPT
+  {
+    fputs(internal::data::reset_color, stream);
   }
-  if (ts.has_foreground()) {
-    has_style = true;
-    internal::fputs<Char>(
-        internal::make_foreground_color<Char>(ts.get_foreground()), f);
+
+  template <> inline void reset_color<wchar_t>(FILE *stream) FMT_NOEXCEPT
+  {
+    fputs(internal::data::wreset_color, stream);
   }
-  if (ts.has_background()) {
-    has_style = true;
-    internal::fputs<Char>(
-        internal::make_background_color<Char>(ts.get_background()), f);
+
+  template <typename Char> inline void reset_color(basic_memory_buffer<Char> &buffer) FMT_NOEXCEPT
+  {
+    const char *begin = data::reset_color;
+    const char *end   = begin + sizeof(data::reset_color) - 1;
+    buffer.append(begin, end);
   }
-  vprint(f, format, args);
-  if (has_style) {
-    internal::reset_color<Char>(f);
+
+  template <typename Char>
+  void vformat_to(basic_memory_buffer<Char> &buf, const text_style &ts,
+                  basic_string_view<Char> format_str, basic_format_args<buffer_context<Char>> args)
+  {
+    bool has_style = false;
+    if (ts.has_emphasis()) {
+      has_style     = true;
+      auto emphasis = internal::make_emphasis<Char>(ts.get_emphasis());
+      buf.append(emphasis.begin(), emphasis.end());
+    }
+    if (ts.has_foreground()) {
+      has_style       = true;
+      auto foreground = internal::make_foreground_color<Char>(ts.get_foreground());
+      buf.append(foreground.begin(), foreground.end());
+    }
+    if (ts.has_background()) {
+      has_style       = true;
+      auto background = internal::make_background_color<Char>(ts.get_background());
+      buf.append(background.begin(), background.end());
+    }
+    vformat_to(buf, format_str, args);
+    if (has_style) {
+      internal::reset_color<Char>(buf);
+    }
   }
+} // namespace internal
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE *f, const text_style &ts, const S &format,
+            basic_format_args<buffer_context<Char>> args)
+{
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format), args);
+  buf.push_back(Char(0));
+  internal::fputs(buf.data(), f);
 }
 
 /**
@@ -531,12 +530,11 @@ void vprint(std::FILE* f, const text_style& ts, const S& format,
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-void print(std::FILE* f, const text_style& ts, const S& format_str,
-           const Args&... args) {
+template <typename S, typename... Args, FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(std::FILE *f, const text_style &ts, const S &format_str, const Args &... args)
+{
   internal::check_format_string<Args...>(format_str);
-  using context = buffer_context<char_t<S> >;
+  using context = buffer_context<char_t<S>>;
   format_arg_store<context, Args...> as{args...};
   vprint(f, ts, format_str, basic_format_args<context>(as));
 }
@@ -548,17 +546,19 @@ void print(std::FILE* f, const text_style& ts, const S& format_str,
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-void print(const text_style& ts, const S& format_str, const Args&... args) {
+template <typename S, typename... Args, FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(const text_style &ts, const S &format_str, const Args &... args)
+{
   return print(stdout, ts, format_str, args...);
 }
 
-template <typename S, typename Char = char_t<S> >
-inline std::basic_string<Char> vformat(
-    const text_style& ts, const S& format_str,
-    basic_format_args<buffer_context<Char> > args) {
-  return internal::vformat(ts, to_string_view(format_str), args);
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(const text_style &ts, const S &format_str,
+                                       basic_format_args<buffer_context<Char>> args)
+{
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format_str), args);
+  return fmt::to_string(buf);
 }
 
 /**
@@ -573,13 +573,14 @@ inline std::basic_string<Char> vformat(
                                       "The answer is {}", 42);
   \endrst
 */
-template <typename S, typename... Args, typename Char = char_t<S> >
-inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
-                                      const Args&... args) {
-  return internal::vformat(ts, to_string_view(format_str),
-                           {internal::make_args_checked(format_str, args...)});
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style &ts, const S &format_str,
+                                      const Args &... args)
+{
+  return vformat(ts, to_string_view(format_str),
+                 {internal::make_args_checked<Args...>(format_str, args...)});
 }
 
 FMT_END_NAMESPACE
 
-#endif  // FMT_COLOR_H_
+#endif // FMT_COLOR_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/compile.h b/packages/seacas/libraries/suplib_cpp/fmt/compile.h
index 39f64a899e66..ab94c20af985 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/compile.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/compile.h
@@ -14,462 +14,574 @@
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
+  // Part of a compiled format string. It can be either literal text or a
+  // replacement field.
   template <typename Char> struct format_part
   {
-  public:
-    struct named_argument_id
-    {
-      FMT_CONSTEXPR named_argument_id(internal::string_view_metadata id) : id(id) {}
-      internal::string_view_metadata id;
-    };
+    enum class kind { arg_index, arg_name, text, replacement };
 
-    struct argument_id
+    struct replacement
     {
-      FMT_CONSTEXPR argument_id() : argument_id(0u) {}
-
-      FMT_CONSTEXPR argument_id(unsigned id) : which(which_arg_id::index), val(id) {}
-
-      FMT_CONSTEXPR argument_id(internal::string_view_metadata id)
-          : which(which_arg_id::named_index), val(id)
-      {
-      }
-
-      enum class which_arg_id { index, named_index };
-
-      which_arg_id which;
-
-      union value {
-        FMT_CONSTEXPR value() : index(0u) {}
-        FMT_CONSTEXPR value(unsigned id) : index(id) {}
-        FMT_CONSTEXPR value(internal::string_view_metadata id) : named_index(id) {}
-
-        unsigned                       index;
-        internal::string_view_metadata named_index;
-      } val;
+      arg_ref<Char>              arg_id;
+      dynamic_format_specs<Char> specs;
     };
 
-    struct specification
-    {
-      FMT_CONSTEXPR specification() : arg_id(0u) {}
-      FMT_CONSTEXPR specification(unsigned id) : arg_id(id) {}
-
-      FMT_CONSTEXPR specification(internal::string_view_metadata id) : arg_id(id) {}
+    kind part_kind;
+    union value {
+      unsigned                arg_index;
+      basic_string_view<Char> str;
+      replacement             repl;
 
-      argument_id                          arg_id;
-      internal::dynamic_format_specs<Char> parsed_specs;
-    };
+      FMT_CONSTEXPR value(unsigned index = 0) : arg_index(index) {}
+      FMT_CONSTEXPR value(basic_string_view<Char> s) : str(s) {}
+      FMT_CONSTEXPR value(replacement r) : repl(r) {}
+    } val;
+    // Position past the end of the argument id.
+    const Char *arg_id_end = nullptr;
 
-    FMT_CONSTEXPR format_part() : which(kind::argument_id), end_of_argument_id(0u), val(0u) {}
+    FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {}) : part_kind(k), val(v) {}
 
-    FMT_CONSTEXPR format_part(internal::string_view_metadata text)
-        : which(kind::text), end_of_argument_id(0u), val(text)
+    static FMT_CONSTEXPR format_part make_arg_index(unsigned index)
     {
+      return format_part(kind::arg_index, index);
     }
-
-    FMT_CONSTEXPR format_part(unsigned id)
-        : which(kind::argument_id), end_of_argument_id(0u), val(id)
+    static FMT_CONSTEXPR format_part make_arg_name(basic_string_view<Char> name)
     {
+      return format_part(kind::arg_name, name);
     }
-
-    FMT_CONSTEXPR format_part(named_argument_id arg_id)
-        : which(kind::named_argument_id), end_of_argument_id(0u), val(arg_id)
+    static FMT_CONSTEXPR format_part make_text(basic_string_view<Char> text)
     {
+      return format_part(kind::text, text);
     }
+    static FMT_CONSTEXPR format_part make_replacement(replacement repl)
+    {
+      return format_part(kind::replacement, repl);
+    }
+  };
 
-    FMT_CONSTEXPR format_part(specification spec)
-        : which(kind::specification), end_of_argument_id(0u), val(spec)
+  template <typename Char> struct part_counter
+  {
+    unsigned num_parts = 0;
+
+    FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
     {
+      if (begin != end)
+        ++num_parts;
     }
 
-    enum class kind { argument_id, named_argument_id, text, specification };
+    FMT_CONSTEXPR void on_arg_id() { ++num_parts; }
+    FMT_CONSTEXPR void on_arg_id(unsigned) { ++num_parts; }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) { ++num_parts; }
 
-    kind        which;
-    std::size_t end_of_argument_id;
-    union value {
-      FMT_CONSTEXPR value() : arg_id(0u) {}
-      FMT_CONSTEXPR value(unsigned id) : arg_id(id) {}
-      FMT_CONSTEXPR value(named_argument_id named_id) : named_arg_id(named_id.id) {}
-      FMT_CONSTEXPR value(internal::string_view_metadata t) : text(t) {}
-      FMT_CONSTEXPR value(specification s) : spec(s) {}
-      unsigned      arg_id;
-      internal::string_view_metadata named_arg_id;
-      internal::string_view_metadata text;
-      specification                  spec;
-    } val;
+    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
+
+    FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *end)
+    {
+      // Find the matching brace.
+      unsigned brace_counter = 0;
+      for (; begin != end; ++begin) {
+        if (*begin == '{') {
+          ++brace_counter;
+        }
+        else if (*begin == '}') {
+          if (brace_counter == 0u)
+            break;
+          --brace_counter;
+        }
+      }
+      return begin;
+    }
+
+    FMT_CONSTEXPR void on_error(const char *) {}
   };
 
-  template <typename Char, typename PartsContainer>
-  class format_preparation_handler : public internal::error_handler
+  // Counts the number of parts in a format string.
+  template <typename Char> FMT_CONSTEXPR unsigned count_parts(basic_string_view<Char> format_str)
+  {
+    part_counter<Char> counter;
+    parse_format_string<true>(format_str, counter);
+    return counter.num_parts;
+  }
+
+  template <typename Char, typename PartHandler> class format_string_compiler : public error_handler
   {
   private:
     using part = format_part<Char>;
 
-  public:
-    using iterator = typename basic_string_view<Char>::iterator;
+    PartHandler               handler_;
+    part                      part_;
+    basic_string_view<Char>   format_str_;
+    basic_parse_context<Char> parse_context_;
 
-    FMT_CONSTEXPR format_preparation_handler(basic_string_view<Char> format, PartsContainer &parts)
-        : parts_(parts), format_(format), parse_context_(format)
+  public:
+    FMT_CONSTEXPR format_string_compiler(basic_string_view<Char> format_str, PartHandler handler)
+        : handler_(handler), format_str_(format_str), parse_context_(format_str)
     {
     }
 
     FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
     {
-      if (begin == end)
-        return;
-      const auto offset = begin - format_.data();
-      const auto size   = end - begin;
-      parts_.push_back(part(string_view_metadata(offset, size)));
+      if (begin != end)
+        handler_(part::make_text({begin, to_unsigned(end - begin)}));
     }
 
-    FMT_CONSTEXPR void on_arg_id() { parts_.push_back(part(parse_context_.next_arg_id())); }
+    FMT_CONSTEXPR void on_arg_id() { part_ = part::make_arg_index(parse_context_.next_arg_id()); }
 
     FMT_CONSTEXPR void on_arg_id(unsigned id)
     {
       parse_context_.check_arg_id(id);
-      parts_.push_back(part(id));
+      part_ = part::make_arg_index(id);
     }
 
-    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id)
-    {
-      const auto view   = string_view_metadata(format_, id);
-      const auto arg_id = typename part::named_argument_id(view);
-      parts_.push_back(part(arg_id));
-    }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id) { part_ = part::make_arg_name(id); }
 
     FMT_CONSTEXPR void on_replacement_field(const Char *ptr)
     {
-      parts_.back().end_of_argument_id = ptr - format_.begin();
+      part_.arg_id_end = ptr;
+      handler_(part_);
     }
 
     FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *end)
     {
-      const auto specs_offset = to_unsigned(begin - format_.begin());
-
-      using parse_context = basic_parse_context<Char>;
-      internal::dynamic_format_specs<Char> parsed_specs;
-      dynamic_specs_handler<parse_context> handler(parsed_specs, parse_context_);
-      begin = parse_format_specs(begin, end, handler);
-
-      if (*begin != '}')
+      auto                                             repl = typename part::replacement();
+      dynamic_specs_handler<basic_parse_context<Char>> handler(repl.specs, parse_context_);
+      auto                                             it = parse_format_specs(begin, end, handler);
+      if (*it != '}')
         on_error("missing '}' in format string");
-
-      auto &last_part = parts_.back();
-      auto  specs     = last_part.which == part::kind::argument_id
-                       ? typename part::specification(last_part.val.arg_id)
-                       : typename part::specification(last_part.val.named_arg_id);
-      specs.parsed_specs           = parsed_specs;
-      last_part                    = part(specs);
-      last_part.end_of_argument_id = specs_offset;
-      return begin;
+      repl.arg_id = part_.part_kind == part::kind::arg_index ? arg_ref<Char>(part_.val.arg_index)
+                                                             : arg_ref<Char>(part_.val.str);
+      auto part       = part::make_replacement(repl);
+      part.arg_id_end = begin;
+      handler_(part);
+      return it;
     }
-
-  private:
-    PartsContainer &          parts_;
-    basic_string_view<Char>   format_;
-    basic_parse_context<Char> parse_context_;
   };
 
-  template <typename Format, typename PreparedPartsProvider, typename... Args> class prepared_format
+  // Compiles a format string and invokes handler(part) for each parsed part.
+  template <bool IS_CONSTEXPR, typename Char, typename PartHandler>
+  FMT_CONSTEXPR void compile_format_string(basic_string_view<Char> format_str, PartHandler handler)
   {
-  public:
-    using char_type     = char_t<Format>;
-    using format_part_t = format_part<char_type>;
-
-    constexpr prepared_format(Format f)
-        : format_(std::move(f)), parts_provider_(to_string_view(format_))
-    {
-    }
-
-    prepared_format() = delete;
+    parse_format_string<IS_CONSTEXPR>(
+        format_str, format_string_compiler<Char, PartHandler>(format_str, handler));
+  }
 
-    using context = buffer_context<char_type>;
+  template <typename Range, typename Context, typename Id>
+  void format_arg(basic_parse_context<typename Range::value_type> &parse_ctx, Context &ctx,
+                  Id arg_id)
+  {
+    ctx.advance_to(visit_format_arg(arg_formatter<Range>(ctx, &parse_ctx), ctx.arg(arg_id)));
+  }
 
-    template <typename Range, typename Context>
-    auto vformat_to(Range out, basic_format_args<Context> args) const -> typename Context::iterator
+  // vformat_to is defined in a subnamespace to prevent ADL.
+  namespace cf {
+    template <typename Context, typename Range, typename CompiledFormat>
+    auto vformat_to(Range out, CompiledFormat &cf, basic_format_args<Context> args) ->
+        typename Context::iterator
     {
-      const auto                     format_view = internal::to_string_view(format_);
-      basic_parse_context<char_type> parse_ctx(format_view);
+      using char_type = typename Context::char_type;
+      basic_parse_context<char_type> parse_ctx(to_string_view(cf.format_str_));
       Context                        ctx(out.begin(), args);
 
-      const auto &parts = parts_provider_.parts();
-      for (auto part_it = parts.begin(); part_it != parts.end(); ++part_it) {
+      const auto &parts = cf.parts();
+      for (auto part_it = std::begin(parts); part_it != std::end(parts); ++part_it) {
         const auto &part  = *part_it;
         const auto &value = part.val;
 
-        switch (part.which) {
+        using format_part_t = format_part<char_type>;
+        switch (part.part_kind) {
         case format_part_t::kind::text: {
-          const auto text   = value.text.to_view(format_view.data());
+          const auto text   = value.str;
           auto       output = ctx.out();
-          auto &&    it     = internal::reserve(output, text.size());
+          auto &&    it     = reserve(output, text.size());
           it                = std::copy_n(text.begin(), text.size(), it);
           ctx.advance_to(output);
-        } break;
-
-        case format_part_t::kind::argument_id: {
-          advance_parse_context_to_specification(parse_ctx, part);
-          format_arg<Range>(parse_ctx, ctx, value.arg_id);
-        } break;
-
-        case format_part_t::kind::named_argument_id: {
-          advance_parse_context_to_specification(parse_ctx, part);
-          const auto named_arg_id = value.named_arg_id.to_view(format_view.data());
-          format_arg<Range>(parse_ctx, ctx, named_arg_id);
-        } break;
-        case format_part_t::kind::specification: {
-          const auto &arg_id_value = value.spec.arg_id.val;
-          const auto  arg =
-              value.spec.arg_id.which == format_part_t::argument_id::which_arg_id::index
-                  ? ctx.arg(arg_id_value.index)
-                  : ctx.arg(arg_id_value.named_index.to_view(to_string_view(format_).data()));
-
-          auto specs = value.spec.parsed_specs;
-
-          handle_dynamic_spec<internal::width_checker>(specs.width, specs.width_ref, ctx,
-                                                       format_view.begin());
-          handle_dynamic_spec<internal::precision_checker>(specs.precision, specs.precision_ref,
-                                                           ctx, format_view.begin());
-
-          check_prepared_specs(specs, arg.type());
-          advance_parse_context_to_specification(parse_ctx, part);
+          break;
+        }
+
+        case format_part_t::kind::arg_index:
+          advance_to(parse_ctx, part.arg_id_end);
+          internal::format_arg<Range>(parse_ctx, ctx, value.arg_index);
+          break;
+
+        case format_part_t::kind::arg_name:
+          advance_to(parse_ctx, part.arg_id_end);
+          internal::format_arg<Range>(parse_ctx, ctx, value.str);
+          break;
+
+        case format_part_t::kind::replacement: {
+          const auto &arg_id_value = value.repl.arg_id.val;
+          const auto  arg          = value.repl.arg_id.kind == arg_id_kind::index
+                               ? ctx.arg(arg_id_value.index)
+                               : ctx.arg(arg_id_value.name);
+
+          auto specs = value.repl.specs;
+
+          handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx);
+          handle_dynamic_spec<precision_checker>(specs.precision, specs.precision_ref, ctx);
+
+          error_handler                        h;
+          numeric_specs_checker<error_handler> checker(h, arg.type());
+          if (specs.align == align::numeric)
+            checker.require_numeric_argument();
+          if (specs.sign != sign::none)
+            checker.check_sign();
+          if (specs.alt)
+            checker.require_numeric_argument();
+          if (specs.precision >= 0)
+            checker.check_precision();
+
+          advance_to(parse_ctx, part.arg_id_end);
           ctx.advance_to(visit_format_arg(arg_formatter<Range>(ctx, nullptr, &specs), arg));
-        } break;
+          break;
+        }
         }
       }
-
       return ctx.out();
     }
+  } // namespace cf
 
-  private:
-    void advance_parse_context_to_specification(basic_parse_context<char_type> &parse_ctx,
-                                                const format_part_t &           part) const
-    {
-      const auto view                = to_string_view(format_);
-      const auto specification_begin = view.data() + part.end_of_argument_id;
-      advance_to(parse_ctx, specification_begin);
-    }
+  struct basic_compiled_format
+  {
+  };
 
-    template <typename Range, typename Context, typename Id>
-    void format_arg(basic_parse_context<char_type> &parse_ctx, Context &ctx, Id arg_id) const
-    {
-      parse_ctx.check_arg_id(arg_id);
-      const auto stopped_at = visit_format_arg(arg_formatter<Range>(ctx), ctx.arg(arg_id));
-      ctx.advance_to(stopped_at);
-    }
+  template <typename S, typename = void> struct compiled_format_base : basic_compiled_format
+  {
+    using char_type       = char_t<S>;
+    using parts_container = std::vector<internal::format_part<char_type>>;
+
+    parts_container compiled_parts;
 
-    template <typename Char>
-    void check_prepared_specs(const basic_format_specs<Char> &specs, internal::type arg_type) const
+    explicit compiled_format_base(basic_string_view<char_type> format_str)
     {
-      internal::error_handler                        h;
-      numeric_specs_checker<internal::error_handler> checker(h, arg_type);
-      if (specs.align == align::numeric)
-        checker.require_numeric_argument();
-      if (specs.sign != sign::none)
-        checker.check_sign();
-      if (specs.alt)
-        checker.require_numeric_argument();
-      if (specs.precision >= 0)
-        checker.check_precision();
+      compile_format_string<false>(format_str, [this](const format_part<char_type> &part) {
+        compiled_parts.push_back(part);
+      });
     }
 
-  private:
-    Format                format_;
-    PreparedPartsProvider parts_provider_;
+    const parts_container &parts() const { return compiled_parts; }
   };
 
-  template <typename Char> struct part_counter
+  template <typename Char, unsigned N> struct format_part_array
   {
-    unsigned num_parts = 0;
+    format_part<Char> data[N]             = {};
+    FMT_CONSTEXPR     format_part_array() = default;
+  };
 
-    FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
+  template <typename Char, unsigned N>
+  FMT_CONSTEXPR format_part_array<Char, N> compile_to_parts(basic_string_view<Char> format_str)
+  {
+    format_part_array<Char, N> parts;
+    unsigned                   counter = 0;
+    // This is not a lambda for compatibility with older compilers.
+    struct
     {
-      if (begin != end)
-        ++num_parts;
+      format_part<Char> *parts;
+      unsigned *         counter;
+      FMT_CONSTEXPR void operator()(const format_part<Char> &part) { parts[(*counter)++] = part; }
+    } collector{parts.data, &counter};
+    compile_format_string<true>(format_str, collector);
+    if (counter < N) {
+      parts.data[counter] = format_part<Char>::make_text(basic_string_view<Char>());
     }
+    return parts;
+  }
 
-    FMT_CONSTEXPR void on_arg_id() { ++num_parts; }
-    FMT_CONSTEXPR void on_arg_id(unsigned) { ++num_parts; }
-    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) { ++num_parts; }
+  template <typename T> constexpr const T &constexpr_max(const T &a, const T &b)
+  {
+    return (a < b) ? b : a;
+  }
 
-    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
+  template <typename S>
+  struct compiled_format_base<S, enable_if_t<is_compile_string<S>::value>> : basic_compiled_format
+  {
+    using char_type = char_t<S>;
 
-    FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *end)
+    FMT_CONSTEXPR explicit compiled_format_base(basic_string_view<char_type>) {}
+
+// Workaround for old compilers. Format string compilation will not be
+// performed there anyway.
+#if FMT_USE_CONSTEXPR
+    static FMT_CONSTEXPR_DECL const unsigned num_format_parts =
+        constexpr_max(count_parts(to_string_view(S())), 1u);
+#else
+    static const unsigned num_format_parts = 1;
+#endif
+
+    using parts_container = format_part<char_type>[num_format_parts];
+
+    const parts_container &parts() const
     {
-      // Find the matching brace.
-      unsigned braces_counter = 0;
-      for (; begin != end; ++begin) {
-        if (*begin == '{') {
-          ++braces_counter;
-        }
-        else if (*begin == '}') {
-          if (braces_counter == 0u)
-            break;
-          --braces_counter;
-        }
-      }
-      return begin;
+      static FMT_CONSTEXPR_DECL const auto compiled_parts =
+          compile_to_parts<char_type, num_format_parts>(internal::to_string_view(S()));
+      return compiled_parts.data;
     }
-
-    FMT_CONSTEXPR void on_error(const char *) {}
   };
 
-  template <typename Format> class compiletime_prepared_parts_type_provider
+  template <typename S, typename... Args> class compiled_format : private compiled_format_base<S>
   {
-  private:
-    using char_type = char_t<Format>;
+  public:
+    using typename compiled_format_base<S>::char_type;
 
-    static FMT_CONSTEXPR unsigned count_parts()
-    {
-      FMT_CONSTEXPR_DECL const auto text = to_string_view(Format{});
-      part_counter<char_type>       counter;
-      internal::parse_format_string</*IS_CONSTEXPR=*/true>(text, counter);
-      return counter.num_parts;
-    }
+  private:
+    basic_string_view<char_type> format_str_;
 
-// Workaround for old compilers. Compile time parts preparation will not be
-// performed with them anyway.
-#if FMT_USE_CONSTEXPR
-    static FMT_CONSTEXPR_DECL const unsigned number_of_format_parts =
-        compiletime_prepared_parts_type_provider::count_parts();
-#else
-    static const unsigned number_of_format_parts = 0u;
-#endif
+    template <typename Context, typename Range, typename CompiledFormat>
+    friend auto cf::vformat_to(Range out, CompiledFormat &cf, basic_format_args<Context> args) ->
+        typename Context::iterator;
 
   public:
-    template <unsigned N> struct format_parts_array
+    compiled_format() = delete;
+    explicit constexpr compiled_format(basic_string_view<char_type> format_str)
+        : compiled_format_base<S>(format_str), format_str_(format_str)
     {
-      using value_type = format_part<char_type>;
-
-      FMT_CONSTEXPR format_parts_array() : arr{} {}
-
-      FMT_CONSTEXPR value_type &operator[](unsigned ind) { return arr[ind]; }
+    }
+  };
 
-      FMT_CONSTEXPR const value_type *begin() const { return arr; }
-      FMT_CONSTEXPR const value_type *end() const { return begin() + N; }
+#ifdef __cpp_if_constexpr
+  template <typename... Args> struct type_list
+  {
+  };
 
-    private:
-      value_type arr[N];
-    };
+  // Returns a reference to the argument at index N from [first, rest...].
+  template <int N, typename T, typename... Args>
+  constexpr const auto &get(const T &first, const Args &... rest)
+  {
+    static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+    if constexpr (N == 0)
+      return first;
+    else
+      return get<N - 1>(rest...);
+  }
 
-    struct empty
-    {
-      // Parts preparator will search for it
-      using value_type = format_part<char_type>;
-    };
+  template <int N, typename> struct get_type_impl;
 
-    using type = conditional_t<number_of_format_parts != 0,
-                               format_parts_array<number_of_format_parts>, empty>;
+  template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>>
+  {
+    using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
   };
 
-  template <typename Parts> class compiletime_prepared_parts_collector
+  template <int N, typename T> using get_type = typename get_type_impl<N, T>::type;
+
+  template <typename Char> struct text
   {
-  private:
-    using format_part = typename Parts::value_type;
+    basic_string_view<Char> data;
+    using char_type = Char;
 
-  public:
-    FMT_CONSTEXPR explicit compiletime_prepared_parts_collector(Parts &parts)
-        : parts_{parts}, counter_{0u}
+    template <typename OutputIt, typename... Args>
+    OutputIt format(OutputIt out, const Args &...) const
     {
+      // TODO: reserve
+      return copy_str<Char>(data.begin(), data.end(), out);
     }
+  };
 
-    FMT_CONSTEXPR void push_back(format_part part) { parts_[counter_++] = part; }
+  template <typename Char>
+  constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos, size_t size)
+  {
+    return {{&s[pos], size}};
+  }
 
-    FMT_CONSTEXPR format_part &back() { return parts_[counter_ - 1]; }
+  template <typename Char, typename OutputIt, typename T,
+            std::enable_if_t<std::is_integral_v<T>, int> = 0>
+  OutputIt format_default(OutputIt out, T value)
+  {
+    // TODO: reserve
+    format_int fi(value);
+    return std::copy(fi.data(), fi.data() + fi.size(), out);
+  }
 
-  private:
-    Parts &  parts_;
-    unsigned counter_;
-  };
+  template <typename Char, typename OutputIt> OutputIt format_default(OutputIt out, Char value)
+  {
+    *out++ = value;
+    return out;
+  }
 
-  template <typename PartsContainer, typename Char>
-  FMT_CONSTEXPR PartsContainer prepare_parts(basic_string_view<Char> format)
+  template <typename Char, typename OutputIt>
+  OutputIt format_default(OutputIt out, const Char *value)
   {
-    PartsContainer parts;
-    internal::parse_format_string</*IS_CONSTEXPR=*/false>(
-        format, format_preparation_handler<Char, PartsContainer>(format, parts));
-    return parts;
+    auto length = std::char_traits<Char>::length(value);
+    return copy_str<Char>(value, value + length, out);
   }
 
-  template <typename PartsContainer, typename Char>
-  FMT_CONSTEXPR PartsContainer prepare_compiletime_parts(basic_string_view<Char> format)
+  // A replacement field that refers to argument N.
+  template <typename Char, typename T, int N> struct field
   {
-    using collector = compiletime_prepared_parts_collector<PartsContainer>;
+    using char_type = Char;
 
-    PartsContainer parts;
-    collector      c(parts);
-    internal::parse_format_string</*IS_CONSTEXPR=*/true>(
-        format, format_preparation_handler<Char, collector>(format, c));
-    return parts;
-  }
+    template <typename OutputIt, typename... Args>
+    OutputIt format(OutputIt out, const Args &... args) const
+    {
+      // This ensures that the argument type is convertile to `const T&`.
+      const T &arg = get<N>(args...);
+      return format_default<Char>(out, arg);
+    }
+  };
 
-  template <typename PartsContainer> class runtime_parts_provider
+  template <typename L, typename R> struct concat
   {
-  public:
-    runtime_parts_provider() = delete;
-    template <typename Char>
-    runtime_parts_provider(basic_string_view<Char> format)
-        : parts_(prepare_parts<PartsContainer>(format))
+    L lhs;
+    R rhs;
+    using char_type = typename L::char_type;
+
+    template <typename OutputIt, typename... Args>
+    OutputIt format(OutputIt out, const Args &... args) const
     {
+      out = lhs.format(out, args...);
+      return rhs.format(out, args...);
     }
+  };
 
-    const PartsContainer &parts() const { return parts_; }
+  template <typename L, typename R> constexpr concat<L, R> make_concat(L lhs, R rhs)
+  {
+    return {lhs, rhs};
+  }
 
-  private:
-    PartsContainer parts_;
+  struct unknown_format
+  {
   };
 
-  template <typename Format, typename PartsContainer> struct compiletime_parts_provider
+  template <typename Char> constexpr size_t parse_text(basic_string_view<Char> str, size_t pos)
   {
-    compiletime_parts_provider() = delete;
-    template <typename Char> FMT_CONSTEXPR compiletime_parts_provider(basic_string_view<Char>) {}
+    for (size_t size = str.size(); pos != size; ++pos) {
+      if (str[pos] == '{' || str[pos] == '}')
+        break;
+    }
+    return pos;
+  }
 
-    const PartsContainer &parts() const
-    {
-      static FMT_CONSTEXPR_DECL const PartsContainer prepared_parts =
-          prepare_compiletime_parts<PartsContainer>(internal::to_string_view(Format{}));
+  template <typename Args, size_t POS, int ID, typename S>
+  constexpr auto compile_format_string(S format_str);
 
-      return prepared_parts;
+  template <typename Args, size_t POS, int ID, typename T, typename S>
+  constexpr auto parse_tail(T head, S format_str)
+  {
+    if constexpr (POS != to_string_view(format_str).size()) {
+      constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+      if constexpr (std::is_same<remove_cvref_t<decltype(tail)>, unknown_format>())
+        return tail;
+      else
+        return make_concat(head, tail);
     }
-  };
+    else {
+      return head;
+    }
+  }
+
+  // Compiles a non-empty format string and returns the compiled representation
+  // or unknown_format() on unrecognized input.
+  template <typename Args, size_t POS, int ID, typename S>
+  constexpr auto compile_format_string(S format_str)
+  {
+    using char_type                            = typename S::char_type;
+    constexpr basic_string_view<char_type> str = format_str;
+    if constexpr (str[POS] == '{') {
+      if (POS + 1 == str.size())
+        throw format_error("unmatched '{' in format string");
+      if constexpr (str[POS + 1] == '{') {
+        return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+      }
+      else if constexpr (str[POS + 1] == '}') {
+        using type = get_type<ID, Args>;
+        if constexpr (std::is_same<type, int>::value) {
+          return parse_tail<Args, POS + 2, ID + 1>(field<char_type, type, ID>(), format_str);
+        }
+        else {
+          return unknown_format();
+        }
+      }
+      else {
+        return unknown_format();
+      }
+    }
+    else if constexpr (str[POS] == '}') {
+      if (POS + 1 == str.size())
+        throw format_error("unmatched '}' in format string");
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    }
+    else {
+      constexpr auto end = parse_text(str, POS + 1);
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), format_str);
+    }
+  }
+#endif // __cpp_if_constexpr
 } // namespace internal
 
 #if FMT_USE_CONSTEXPR
+#ifdef __cpp_if_constexpr
 template <typename... Args, typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-FMT_CONSTEXPR auto compile(S format_str) -> internal::prepared_format<
-    S,
-    internal::compiletime_parts_provider<
-        S, typename internal::compiletime_prepared_parts_type_provider<S>::type>,
-    Args...>
+constexpr auto compile(S format_str)
 {
-  return format_str;
+  constexpr basic_string_view<typename S::char_type> str = format_str;
+  if constexpr (str.size() == 0) {
+    return internal::make_text(str, 0, 0);
+  }
+  else {
+    constexpr auto result =
+        internal::compile_format_string<internal::type_list<Args...>, 0, 0>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(result)>, internal::unknown_format>()) {
+      return internal::compiled_format<S, Args...>(to_string_view(format_str));
+    }
+    else {
+      return result;
+    }
+  }
 }
-#endif
 
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(!std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
+std::basic_string<Char> format(const CompiledFormat &cf, const Args &... args)
+{
+  basic_memory_buffer<Char> buffer;
+  using range   = buffer_range<Char>;
+  using context = buffer_context<Char>;
+  cf.format(std::back_inserter(buffer), args...);
+  return to_string(buffer);
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(!std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
+OutputIt format_to(OutputIt out, const CompiledFormat &cf, const Args &... args)
+{
+  return cf.format(out, args...);
+}
+#else
+template <typename... Args, typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto compile(S format_str) -> internal::compiled_format<S, Args...>
+{
+  return internal::compiled_format<S, Args...>(to_string_view(format_str));
+}
+#endif // __cpp_if_constexpr
+#endif // FMT_USE_CONSTEXPR
+
+// Compiles the format string which must be a string literal.
 template <typename... Args, typename Char, size_t N>
-auto compile(const Char (&format_str)[N]) -> internal::prepared_format<
-    std::basic_string<Char>,
-    internal::runtime_parts_provider<std::vector<internal::format_part<Char>>>, Args...>
+auto compile(const Char (&format_str)[N]) -> internal::compiled_format<const Char *, Args...>
 {
-  return std::basic_string<Char>(format_str, N - 1);
+  return internal::compiled_format<const Char *, Args...>(
+      basic_string_view<Char>(format_str, N - 1));
 }
 
 template <typename CompiledFormat, typename... Args,
-          typename Char = typename CompiledFormat::char_type>
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
 std::basic_string<Char> format(const CompiledFormat &cf, const Args &... args)
 {
   basic_memory_buffer<Char> buffer;
-  using range   = internal::buffer_range<Char>;
+  using range   = buffer_range<Char>;
   using context = buffer_context<Char>;
-  cf.template vformat_to<range, context>(range(buffer), {make_format_args<context>(args...)});
+  internal::cf::vformat_to<context>(range(buffer), cf, {make_format_args<context>(args...)});
   return to_string(buffer);
 }
 
-template <typename OutputIt, typename CompiledFormat, typename... Args>
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format, CompiledFormat>::value)>
 OutputIt format_to(OutputIt out, const CompiledFormat &cf, const Args &... args)
 {
   using char_type = typename CompiledFormat::char_type;
   using range     = internal::output_range<OutputIt, char_type>;
   using context   = format_context_t<OutputIt, char_type>;
-  return cf.template vformat_to<range, context>(range(out), {make_format_args<context>(args...)});
+  return internal::cf::vformat_to<context>(range(out), cf, {make_format_args<context>(args...)});
 }
 
 template <typename OutputIt, typename CompiledFormat, typename... Args,
@@ -484,9 +596,7 @@ format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, const CompiledF
 template <typename CompiledFormat, typename... Args>
 std::size_t formatted_size(const CompiledFormat &cf, const Args &... args)
 {
-  return fmt::format_to(internal::counting_iterator<typename CompiledFormat::char_type>(), cf,
-                        args...)
-      .count();
+  return format_to(internal::counting_iterator(), cf, args...).count();
 }
 
 FMT_END_NAMESPACE
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/core.h b/packages/seacas/libraries/suplib_cpp/fmt/core.h
index 19a718cb788f..1a1ecfe1e83a 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/core.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/core.h
@@ -52,6 +52,12 @@
 #define FMT_HAS_GXX_CXX11 0
 #endif
 
+#ifdef __NVCC__
+#define FMT_NVCC __NVCC__
+#else
+#define FMT_NVCC 0
+#endif
+
 #ifdef _MSC_VER
 #define FMT_MSC_VER _MSC_VER
 #else
@@ -63,7 +69,8 @@
 #ifndef FMT_USE_CONSTEXPR
 #define FMT_USE_CONSTEXPR                                                                          \
   (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 ||                                \
-   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
+   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&                                          \
+      !FMT_NVCC
 #endif
 #if FMT_USE_CONSTEXPR
 #define FMT_CONSTEXPR constexpr
@@ -134,8 +141,8 @@
 #endif
 #endif
 
-// Workaround broken [[deprecated]] in the Intel compiler.
-#if defined(__INTEL_COMPILER) || defined(__NVCC__)
+// Workaround broken [[deprecated]] in the Intel compiler and NVCC.
+#if defined(__INTEL_COMPILER) || FMT_NVCC
 #define FMT_DEPRECATED_ALIAS
 #else
 #define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
@@ -203,6 +210,7 @@ template <bool B, class T, class F> using conditional_t = typename std::conditio
 template <bool B> using bool_constant                   = std::integral_constant<bool, B>;
 template <typename T> using remove_reference_t          = typename std::remove_reference<T>::type;
 template <typename T> using remove_const_t              = typename std::remove_const<T>::type;
+template <typename T> using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
 
 struct monostate
 {
@@ -231,7 +239,25 @@ namespace internal {
   };
 #endif
 
-  // Casts nonnegative integer to unsigned.
+#ifdef FMT_USE_INT128
+// Do nothing.
+#elif defined(__SIZEOF_INT128__)
+#define FMT_USE_INT128 1
+  using int128_t                                 = __int128_t;
+  using uint128_t                                = __uint128_t;
+#else
+#define FMT_USE_INT128 0
+#endif
+#if !FMT_USE_INT128
+  struct int128_t
+  {
+  };
+  struct uint128_t
+  {
+  };
+#endif
+
+  // Casts a nonnegative integer to unsigned.
   template <typename Int>
   FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value)
   {
@@ -296,6 +322,8 @@ template <typename Char> class basic_string_view
   FMT_CONSTEXPR iterator begin() const { return data_; }
   FMT_CONSTEXPR iterator end() const { return data_ + size_; }
 
+  FMT_CONSTEXPR const Char &operator[](size_t pos) const { return data_[pos]; }
+
   FMT_CONSTEXPR void remove_prefix(size_t n)
   {
     data_ += n;
@@ -681,10 +709,13 @@ namespace internal {
     uint_type,
     long_long_type,
     ulong_long_type,
+    int128_type,
+    uint128_type,
     bool_type,
     char_type,
     last_integer_type = char_type,
     // followed by floating-point types.
+    float_type,
     double_type,
     long_double_type,
     last_numeric_type = long_double_type,
@@ -711,21 +742,24 @@ namespace internal {
   FMT_TYPE_CONSTANT(unsigned, uint_type);
   FMT_TYPE_CONSTANT(long long, long_long_type);
   FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+  FMT_TYPE_CONSTANT(int128_t, int128_type);
+  FMT_TYPE_CONSTANT(uint128_t, uint128_type);
   FMT_TYPE_CONSTANT(bool, bool_type);
   FMT_TYPE_CONSTANT(Char, char_type);
+  FMT_TYPE_CONSTANT(float, float_type);
   FMT_TYPE_CONSTANT(double, double_type);
   FMT_TYPE_CONSTANT(long double, long_double_type);
   FMT_TYPE_CONSTANT(const Char *, cstring_type);
   FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
   FMT_TYPE_CONSTANT(const void *, pointer_type);
 
-  FMT_CONSTEXPR bool is_integral(type t)
+  FMT_CONSTEXPR bool is_integral_type(type t)
   {
     FMT_ASSERT(t != named_arg_type, "invalid argument type");
     return t > none_type && t <= last_integer_type;
   }
 
-  FMT_CONSTEXPR bool is_arithmetic(type t)
+  FMT_CONSTEXPR bool is_arithmetic_type(type t)
   {
     FMT_ASSERT(t != named_arg_type, "invalid argument type");
     return t > none_type && t <= last_numeric_type;
@@ -755,8 +789,11 @@ namespace internal {
       unsigned                         uint_value;
       long long                        long_long_value;
       unsigned long long               ulong_long_value;
+      int128_t                         int128_value;
+      uint128_t                        uint128_value;
       bool                             bool_value;
       char_type                        char_value;
+      float                            float_value;
       double                           double_value;
       long double                      long_double_value;
       const void *                     pointer;
@@ -769,6 +806,9 @@ namespace internal {
     FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
     value(long long val) : long_long_value(val) {}
     value(unsigned long long val) : ulong_long_value(val) {}
+    value(int128_t val) : int128_value(val) {}
+    value(uint128_t val) : uint128_value(val) {}
+    value(float val) : float_value(val) {}
     value(double val) : double_value(val) {}
     value(long double val) : long_double_value(val) {}
     value(bool val) : bool_value(val) {}
@@ -821,16 +861,18 @@ namespace internal {
   {
     using char_type = typename Context::char_type;
 
-    FMT_CONSTEXPR int      map(signed char val) { return val; }
-    FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
-    FMT_CONSTEXPR int      map(short val) { return val; }
-    FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
-    FMT_CONSTEXPR int      map(int val) { return val; }
-    FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
-    FMT_CONSTEXPR long_type map(long val) { return val; }
+    FMT_CONSTEXPR int                map(signed char val) { return val; }
+    FMT_CONSTEXPR unsigned           map(unsigned char val) { return val; }
+    FMT_CONSTEXPR int                map(short val) { return val; }
+    FMT_CONSTEXPR unsigned           map(unsigned short val) { return val; }
+    FMT_CONSTEXPR int                map(int val) { return val; }
+    FMT_CONSTEXPR unsigned           map(unsigned val) { return val; }
+    FMT_CONSTEXPR long_type          map(long val) { return val; }
     FMT_CONSTEXPR ulong_type         map(unsigned long val) { return val; }
     FMT_CONSTEXPR long long          map(long long val) { return val; }
     FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
+    FMT_CONSTEXPR int128_t           map(int128_t val) { return val; }
+    FMT_CONSTEXPR uint128_t          map(uint128_t val) { return val; }
     FMT_CONSTEXPR bool               map(bool val) { return val; }
 
     template <typename T, FMT_ENABLE_IF(is_char<T>::value)> FMT_CONSTEXPR char_type map(T val)
@@ -840,7 +882,7 @@ namespace internal {
       return val;
     }
 
-    FMT_CONSTEXPR double      map(float val) { return static_cast<double>(val); }
+    FMT_CONSTEXPR float       map(float val) { return val; }
     FMT_CONSTEXPR double      map(double val) { return val; }
     FMT_CONSTEXPR long double map(long double val) { return val; }
 
@@ -860,6 +902,14 @@ namespace internal {
     {
       return basic_string_view<char_type>(val);
     }
+    template <typename T,
+              FMT_ENABLE_IF(std::is_constructible<std_string_view<char_type>, T>::value &&
+                            !std::is_constructible<basic_string_view<char_type>, T>::value &&
+                            !is_string<T>::value)>
+    FMT_CONSTEXPR basic_string_view<char_type> map(const T &val)
+    {
+      return std_string_view<char_type>(val);
+    }
     FMT_CONSTEXPR const char *map(const signed char *val)
     {
       static_assert(std::is_same<char_type, char>::value, "invalid string type");
@@ -887,9 +937,10 @@ namespace internal {
     template <typename T,
               FMT_ENABLE_IF(std::is_enum<T>::value && !has_formatter<T, Context>::value &&
                             !has_fallback_formatter<T, Context>::value)>
-    FMT_CONSTEXPR int map(const T &val)
+    FMT_CONSTEXPR auto map(const T &val)
+        -> decltype(map(static_cast<typename std::underlying_type<T>::type>(val)))
     {
-      return static_cast<int>(val);
+      return map(static_cast<typename std::underlying_type<T>::type>(val));
     }
     template <typename T, FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
                                         (has_formatter<T, Context>::value ||
@@ -913,8 +964,9 @@ namespace internal {
   using mapped_type_constant = type_constant<decltype(arg_mapper<Context>().map(std::declval<T>())),
                                              typename Context::char_type>;
 
+  enum { packed_arg_bits = 5 };
   // Maximum number of arguments with packed types.
-  enum { max_packed_args = 15 };
+  enum { max_packed_args = 63 / packed_arg_bits };
   enum : unsigned long long { is_unpacked_bit = 1ull << 63 };
 
   template <typename Context> class arg_map;
@@ -961,8 +1013,8 @@ template <typename Context> class basic_format_arg
 
   internal::type type() const { return type_; }
 
-  bool is_integral() const { return internal::is_integral(type_); }
-  bool is_arithmetic() const { return internal::is_arithmetic(type_); }
+  bool is_integral() const { return internal::is_integral_type(type_); }
+  bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
 };
 
 /**
@@ -984,8 +1036,16 @@ FMT_CONSTEXPR auto visit_format_arg(Visitor &&vis, const basic_format_arg<Contex
   case internal::uint_type: return vis(arg.value_.uint_value);
   case internal::long_long_type: return vis(arg.value_.long_long_value);
   case internal::ulong_long_type: return vis(arg.value_.ulong_long_value);
+#if FMT_USE_INT128
+  case internal::int128_type: return vis(arg.value_.int128_value);
+  case internal::uint128_type: return vis(arg.value_.uint128_value);
+#else
+  case internal::int128_type:
+  case internal::uint128_type: break;
+#endif
   case internal::bool_type: return vis(arg.value_.bool_value);
   case internal::char_type: return vis(arg.value_.char_value);
+  case internal::float_type: return vis(arg.value_.float_value);
   case internal::double_type: return vis(arg.value_.double_value);
   case internal::long_double_type: return vis(arg.value_.long_double_value);
   case internal::cstring_type: return vis(arg.value_.string.data);
@@ -1058,7 +1118,8 @@ namespace internal {
   template <typename Context, typename Arg, typename... Args>
   constexpr unsigned long long encode_types()
   {
-    return mapped_type_constant<Arg, Context>::value | (encode_types<Context, Args...>() << 4);
+    return mapped_type_constant<Arg, Context>::value |
+           (encode_types<Context, Args...>() << packed_arg_bits);
   }
 
   template <typename Context, typename T>
@@ -1108,9 +1169,9 @@ template <typename OutputIt, typename Char> class basic_format_context
    Constructs a ``basic_format_context`` object. References to the arguments are
    stored in the object so make sure they have appropriate lifetimes.
    */
-  basic_format_context(OutputIt out_it, basic_format_args<basic_format_context> ctx_args,
+  basic_format_context(OutputIt out, basic_format_args<basic_format_context> ctx_args,
                        internal::locale_ref loc = internal::locale_ref())
-      : out_(out_it), args_(ctx_args), loc_(loc)
+      : out_(out), args_(ctx_args), loc_(loc)
   {
   }
 
@@ -1205,8 +1266,9 @@ template <typename Context> class basic_format_args
 
   internal::type type(int index) const
   {
-    int shift = index * 4;
-    return static_cast<internal::type>((types_ & (0xfull << shift)) >> shift);
+    int shift = index * internal::packed_arg_bits;
+    int mask  = (1 << internal::packed_arg_bits) - 1;
+    return static_cast<internal::type>((types_ >> shift) & mask);
   }
 
   friend class internal::arg_map<Context>;
@@ -1364,11 +1426,9 @@ namespace internal {
   inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
   make_args_checked(const S &format_str, const remove_reference_t<Args> &... args)
   {
-#ifndef __INTEL_COMPILER
     static_assert(all_true<(!std::is_base_of<view, remove_reference_t<Args>>() ||
                             !std::is_reference<Args>())...>::value,
                   "passing views as lvalues is disallowed");
-#endif
     check_format_string<remove_const_t<remove_reference_t<Args>>...>(format_str);
     return {args...};
   }
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
index 147062fe5d38..283d6912e12f 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
@@ -17,49 +17,43 @@
 #include <climits>
 #include <cmath>
 #include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
-#include <cstring>  // for std::memmove
+#include <cstring> // for std::memmove
 #include <cwchar>
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-#  include <locale>
+#include <locale>
 #endif
 
 #if FMT_USE_WINDOWS_H
-#  if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#    include <windows.h>
-#  else
-#    define NOMINMAX
-#    include <windows.h>
-#    undef NOMINMAX
-#  endif
+#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
+#include <windows.h>
+#else
+#define NOMINMAX
+#include <windows.h>
+#undef NOMINMAX
+#endif
 #endif
 
 #if FMT_EXCEPTIONS
-#  define FMT_TRY try
-#  define FMT_CATCH(x) catch (x)
+#define FMT_TRY try
+#define FMT_CATCH(x) catch (x)
 #else
-#  define FMT_TRY if (true)
-#  define FMT_CATCH(x) if (false)
+#define FMT_TRY if (true)
+#define FMT_CATCH(x) if (false)
 #endif
 
 #ifdef _MSC_VER
-#  pragma warning(push)
-#  pragma warning(disable : 4127)  // conditional expression is constant
-#  pragma warning(disable : 4702)  // unreachable code
-// Disable deprecation warning for strerror. The latter is not called but
-// MSVC fails to detect it.
-#  pragma warning(disable : 4996)
+#pragma warning(push)
+#pragma warning(disable : 4702) // unreachable code
 #endif
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
-inline fmt::internal::null<> strerror_r(int, char*, ...) {
-  return fmt::internal::null<>();
-}
-inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) {
+inline fmt::internal::null<> strerror_r(int, char *, ...) { return fmt::internal::null<>(); }
+inline fmt::internal::null<> strerror_s(char *, std::size_t, ...)
+{
   return fmt::internal::null<>();
 }
 
@@ -67,773 +61,1203 @@ FMT_BEGIN_NAMESPACE
 namespace internal {
 
 #ifndef _MSC_VER
-#  define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-#  define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-using format_func = void (*)(internal::buffer<char>&, int, string_view);
-
-// Portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-FMT_FUNC int safe_strerror(int error_code, char*& buffer,
-                           std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
-
-  class dispatcher {
-   private:
-    int error_code_;
-    char*& buffer_;
-    std::size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher&) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    int handle(char* message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
+#define FMT_SNPRINTF snprintf
+#else // _MSC_VER
+  inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...)
+  {
+    va_list args;
+    va_start(args, format);
+    int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
+    va_end(args);
+    return result;
+  }
+#define FMT_SNPRINTF fmt_snprintf
+#endif // _MSC_VER
+
+  using format_func = void (*)(internal::buffer<char> &, int, string_view);
+
+  // A portable thread-safe version of strerror.
+  // Sets buffer to point to a string describing the error code.
+  // This can be either a pointer to a string stored in buffer,
+  // or a pointer to some static immutable string.
+  // Returns one of the following values:
+  //   0      - success
+  //   ERANGE - buffer is not large enough to store the error message
+  //   other  - failure
+  // Buffer should be at least of size 1.
+  FMT_FUNC int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT
+  {
+    FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
+
+    class dispatcher
+    {
+    private:
+      int         error_code_;
+      char *&     buffer_;
+      std::size_t buffer_size_;
+
+      // A noop assignment operator to avoid bogus warnings.
+      void operator=(const dispatcher &) {}
+
+      // Handle the result of XSI-compliant version of strerror_r.
+      int handle(int result)
+      {
+        // glibc versions before 2.13 return result in errno.
+        return result == -1 ? errno : result;
+      }
 
-    // Handle the case when strerror_r is not available.
-    int handle(internal::null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
+      // Handle the result of GNU-specific version of strerror_r.
+      int handle(char *message)
+      {
+        // If the buffer is full then the message is probably truncated.
+        if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
+          return ERANGE;
+        buffer_ = message;
+        return 0;
+      }
 
-    // Fallback to strerror_s when strerror_r is not available.
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
-                                                                : result;
-    }
+      // Handle the case when strerror_r is not available.
+      int handle(internal::null<>)
+      {
+        return fallback(strerror_s(buffer_, buffer_size_, error_code_));
+      }
+
+      // Fallback to strerror_s when strerror_r is not available.
+      int fallback(int result)
+      {
+        // If the buffer is full then the message is probably truncated.
+        return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE : result;
+      }
 
 #if !FMT_MSC_VER
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(internal::null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
+      // Fallback to strerror if strerror_r and strerror_s are not available.
+      int fallback(internal::null<>)
+      {
+        errno   = 0;
+        buffer_ = strerror(error_code_);
+        return errno;
+      }
 #endif
 
-   public:
-    dispatcher(int err_code, char*& buf, std::size_t buf_size)
-        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
-}
+    public:
+      dispatcher(int err_code, char *&buf, std::size_t buf_size)
+          : error_code_(err_code), buffer_(buf), buffer_size_(buf_size)
+      {
+      }
 
-FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
-                                string_view message) FMT_NOEXCEPT {
-  // Report error code making sure that the output fits into
-  // inline_buffer_size to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.resize(0);
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  auto abs_value = static_cast<uint32_or_64_t<int>>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
+      int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
+    };
+    return dispatcher(error_code, buffer, buffer_size).run();
   }
-  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
-  internal::writer w(out);
-  if (message.size() <= inline_buffer_size - error_code_size) {
-    w.write(message);
-    w.write(SEP);
+
+  FMT_FUNC void format_error_code(internal::buffer<char> &out, int error_code,
+                                  string_view message) FMT_NOEXCEPT
+  {
+    // Report error code making sure that the output fits into
+    // inline_buffer_size to avoid dynamic memory allocation and potential
+    // bad_alloc.
+    out.resize(0);
+    static const char SEP[]       = ": ";
+    static const char ERROR_STR[] = "error ";
+    // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+    std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+    auto        abs_value       = static_cast<uint32_or_64_or_128_t<int>>(error_code);
+    if (internal::is_negative(error_code)) {
+      abs_value = 0 - abs_value;
+      ++error_code_size;
+    }
+    error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
+    internal::writer w(out);
+    if (message.size() <= inline_buffer_size - error_code_size) {
+      w.write(message);
+      w.write(SEP);
+    }
+    w.write(ERROR_STR);
+    w.write(error_code);
+    assert(out.size() <= inline_buffer_size);
   }
-  w.write(ERROR_STR);
-  w.write(error_code);
-  assert(out.size() <= inline_buffer_size);
-}
 
-// A wrapper around fwrite that throws on error.
-FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
-                           FILE* stream) {
-  size_t written = std::fwrite(ptr, size, count, stream);
-  if (written < count) {
-    FMT_THROW(system_error(errno, "cannot write to file"));
+  // A wrapper around fwrite that throws on error.
+  FMT_FUNC void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
+  {
+    size_t written = std::fwrite(ptr, size, count, stream);
+    if (written < count) {
+      FMT_THROW(system_error(errno, "cannot write to file"));
+    }
   }
-}
 
-FMT_FUNC void report_error(format_func func, int error_code,
-                           string_view message) FMT_NOEXCEPT {
-  memory_buffer full_message;
-  func(full_message, error_code, message);
-  // Don't use fwrite_fully because the latter may throw.
-  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
-}
-}  // namespace internal
+  FMT_FUNC void report_error(format_func func, int error_code, string_view message) FMT_NOEXCEPT
+  {
+    memory_buffer full_message;
+    func(full_message, error_code, message);
+    // Don't use fwrite_fully because the latter may throw.
+    (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
+    std::fputc('\n', stderr);
+  }
+} // namespace internal
 
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
 namespace internal {
 
-template <typename Locale>
-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
+  template <typename Locale> locale_ref::locale_ref(const Locale &loc) : locale_(&loc)
+  {
+    static_assert(std::is_same<Locale, std::locale>::value, "");
+  }
 
-template <typename Locale> Locale locale_ref::get() const {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
+  template <typename Locale> Locale locale_ref::get() const
+  {
+    static_assert(std::is_same<Locale, std::locale>::value, "");
+    return locale_ ? *static_cast<const std::locale *>(locale_) : std::locale();
+  }
 
-template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .thousands_sep();
-}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
-}
-}  // namespace internal
+  template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc)
+  {
+    return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).thousands_sep();
+  }
+  template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc)
+  {
+    return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).decimal_point();
+  }
+} // namespace internal
 #else
-template <typename Char>
-FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
+template <typename Char> FMT_FUNC Char internal::thousands_sep_impl(locale_ref)
+{
   return FMT_STATIC_THOUSANDS_SEPARATOR;
 }
-template <typename Char>
-FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
-  return '.';
-}
+template <typename Char> FMT_FUNC Char internal::decimal_point_impl(locale_ref) { return '.'; }
 #endif
 
 FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT {}
 FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT {}
 
-FMT_FUNC void system_error::init(int err_code, string_view format_str,
-                                 format_args args) {
+FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args)
+{
   error_code_ = err_code;
   memory_buffer buffer;
   format_system_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error& base = *this;
-  base = std::runtime_error(to_string(buffer));
+  std::runtime_error &base = *this;
+  base                     = std::runtime_error(to_string(buffer));
 }
 
 namespace internal {
 
-template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
-  // Assume little endian; pointer formatting is implementation-defined anyway.
-  int i = static_cast<int>(sizeof(void*)) - 1;
-  while (i > 0 && n.value[i] == 0) --i;
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
-}
+  template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n)
+  {
+    // Assume little endian; pointer formatting is implementation-defined anyway.
+    int i = static_cast<int>(sizeof(void *)) - 1;
+    while (i > 0 && n.value[i] == 0)
+      --i;
+    auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+    return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
+  }
 
-template <typename T>
-int format_float(char* buf, std::size_t size, const char* format, int precision,
-                 T value) {
+  template <typename T>
+  int format_float(char *buf, std::size_t size, const char *format, int precision, T value)
+  {
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (precision > 100000)
-    throw std::runtime_error(
-        "fuzz mode - avoid large allocation inside snprintf");
+    if (precision > 100000)
+      throw std::runtime_error("fuzz mode - avoid large allocation inside snprintf");
 #endif
-  // Suppress the warning about nonliteral format string.
-  auto snprintf_ptr = FMT_SNPRINTF;
-  return precision < 0 ? snprintf_ptr(buf, size, format, value)
-                       : snprintf_ptr(buf, size, format, precision, value);
-}
+    // Suppress the warning about nonliteral format string.
+    auto snprintf_ptr = FMT_SNPRINTF;
+    return precision < 0 ? snprintf_ptr(buf, size, format, value)
+                         : snprintf_ptr(buf, size, format, precision, value);
+  }
 
-template <typename T>
-const char basic_data<T>::digits[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-template <typename T>
-const char basic_data<T>::hex_digits[] = "0123456789abcdef";
-
-#define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, \
-      factor * 1000000, factor * 10000000, factor * 100000000,               \
-      factor * 1000000000
-
-template <typename T>
-const uint64_t basic_data<T>::powers_of_10_64[] = {
-    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
-    10000000000000000000ull};
-
-template <typename T>
-const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
-                                                           FMT_POWERS_OF_10(1)};
-
-template <typename T>
-const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
-    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
-    10000000000000000000ull};
-
-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-// These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::pow10_significands[] = {
-    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-};
+  template <typename T>
+  const char basic_data<T>::digits[] = "0001020304050607080910111213141516171819"
+                                       "2021222324252627282930313233343536373839"
+                                       "4041424344454647484950515253545556575859"
+                                       "6061626364656667686970717273747576777879"
+                                       "8081828384858687888990919293949596979899";
+
+  template <typename T> const char basic_data<T>::hex_digits[] = "0123456789abcdef";
+
+#define FMT_POWERS_OF_10(factor)                                                                   \
+  factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, factor * 1000000,     \
+      factor * 10000000, factor * 100000000, factor * 1000000000
+
+  template <typename T>
+  const uint64_t basic_data<T>::powers_of_10_64[] = {
+      1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
+
+  template <typename T>
+  const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0, FMT_POWERS_OF_10(1)};
+
+  template <typename T>
+  const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
+      0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
+
+  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+  // These are generated by support/compute-powers.py.
+  template <typename T>
+  const uint64_t basic_data<T>::pow10_significands[] = {
+      0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
+      0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f,
+      0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+      0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
+      0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5,
+      0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+      0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
+      0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd,
+      0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+      0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
+      0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c,
+      0x9c40000000000000, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+      0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
+      0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a,
+      0x924d692ca61be758, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+      0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+      0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece,
+      0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+      0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+      0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429,
+      0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+      0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
+  };
 
-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-// to significands above.
-template <typename T>
-const int16_t basic_data<T>::pow10_exponents[] = {
-    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
-    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
-    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
-    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-
-template <typename T>
-const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
-template <typename T>
-const char basic_data<T>::background_color[] = "\x1b[48;2;";
-template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
-
-template <typename T> struct bits {
-  static FMT_CONSTEXPR_DECL const int value =
-      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
-};
+  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+  // to significands above.
+  template <typename T>
+  const int16_t basic_data<T>::pow10_exponents[] = {
+      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
+      -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,  -635, -608, -582, -555,
+      -529,  -502,  -475,  -449,  -422,  -396,  -369,  -343,  -316,  -289, -263, -236, -210,
+      -183,  -157,  -130,  -103,  -77,   -50,   -24,   3,     30,    56,   83,   109,  136,
+      162,   189,   216,   242,   269,   295,   322,   348,   375,   402,  428,  455,  481,
+      508,   534,   561,   588,   614,   641,   667,   694,   720,   747,  774,  800,  827,
+      853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
+
+  template <typename T> const char    basic_data<T>::foreground_color[] = "\x1b[38;2;";
+  template <typename T> const char    basic_data<T>::background_color[] = "\x1b[48;2;";
+  template <typename T> const char    basic_data<T>::reset_color[]      = "\x1b[0m";
+  template <typename T> const wchar_t basic_data<T>::wreset_color[]     = L"\x1b[0m";
+  template <typename T> const char    basic_data<T>::signs[]            = {0, '-', '+', ' '};
+
+  template <typename T> struct bits
+  {
+    static FMT_CONSTEXPR_DECL const int value =
+        static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
+  };
 
-// A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  using significand_type = uint64_t;
-
-  // All sizes are in bits.
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-      std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-      1ull << double_significand_size;
-
- public:
-  significand_type f;
-  int e;
-
-  static FMT_CONSTEXPR_DECL const int significand_size =
-      bits<significand_type>::value;
-
-  fp() : f(0), e(0) {}
-  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double> explicit fp(Double d) {
-    // Assume double is in the format [sign][exponent][significand].
-    using limits = std::numeric_limits<Double>;
-    const int exponent_size =
-        bits<Double>::value - double_significand_size - 1;  // -1 for sign
-    const uint64_t significand_mask = implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-    auto u = bit_cast<uint64_t>(d);
-    auto biased_e = (u & exponent_mask) >> double_significand_size;
-    f = u & significand_mask;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-  }
+  class fp;
+  template <int SHIFT = 0> fp normalize(fp value);
+
+  // A handmade floating-point number f * pow(2, e).
+  class fp
+  {
+  private:
+    using significand_type = uint64_t;
+
+    // All sizes are in bits.
+    // Subtract 1 to account for an implicit most significant bit in the
+    // normalized form.
+    static FMT_CONSTEXPR_DECL const int double_significand_size =
+        std::numeric_limits<double>::digits - 1;
+    static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size;
+
+  public:
+    significand_type f;
+    int              e;
+
+    static FMT_CONSTEXPR_DECL const int significand_size = bits<significand_type>::value;
+
+    fp() : f(0), e(0) {}
+    fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
+
+    // Constructs fp from an IEEE754 double. It is a template to prevent compile
+    // errors on platforms where double is not IEEE754.
+    template <typename Double> explicit fp(Double d) { assign(d); }
+
+    // Normalizes the value converted from double and multiplied by (1 << SHIFT).
+    template <int SHIFT> friend fp normalize(fp value)
+    {
+      // Handle subnormals.
+      const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
+      while ((value.f & shifted_implicit_bit) == 0) {
+        value.f <<= 1;
+        --value.e;
+      }
+      // Subtract 1 to account for hidden bit.
+      const auto offset = fp::significand_size - fp::double_significand_size - SHIFT - 1;
+      value.f <<= offset;
+      value.e -= offset;
+      return value;
+    }
 
-  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-  template <int SHIFT = 0> void normalize() {
-    // Handle subnormals.
-    auto shifted_implicit_bit = implicit_bit << SHIFT;
-    while ((f & shifted_implicit_bit) == 0) {
-      f <<= 1;
-      --e;
-    }
-    // Subtract 1 to account for hidden bit.
-    auto offset = significand_size - double_significand_size - SHIFT - 1;
-    f <<= offset;
-    e -= offset;
-  }
+    // Assigns d to this and return true iff predecessor is closer than successor.
+    template <typename Double> bool assign(Double d)
+    {
+      // Assume double is in the format [sign][exponent][significand].
+      using limits            = std::numeric_limits<Double>;
+      const int exponent_size = bits<Double>::value - double_significand_size - 1; // -1 for sign
+      const uint64_t significand_mask = implicit_bit - 1;
+      const uint64_t exponent_mask    = (~0ull >> 1) & ~significand_mask;
+      const int      exponent_bias    = (1 << exponent_size) - limits::max_exponent - 1;
+      auto           u                = bit_cast<uint64_t>(d);
+      f                               = u & significand_mask;
+      auto biased_e                   = (u & exponent_mask) >> double_significand_size;
+      // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
+      // the smallest normalized number (biased_e > 1).
+      bool is_predecessor_closer = f == 0 && biased_e > 1;
+      if (biased_e != 0)
+        f += implicit_bit;
+      else
+        biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
+      e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
+      return is_predecessor_closer;
+    }
 
-  // Compute lower and upper boundaries (m^- and m^+ in the Grisu paper), where
-  // a boundary is a value half way between the number and its predecessor
-  // (lower) or successor (upper). The upper boundary is normalized and lower
-  // has the same exponent but may be not normalized.
-  void compute_boundaries(fp& lower, fp& upper) const {
-    lower =
-        f == implicit_bit ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
-    upper = fp((f << 1) + 1, e - 1);
-    upper.normalize<1>();  // 1 is to account for the exponent shift above.
-    lower.f <<= lower.e - upper.e;
-    lower.e = upper.e;
-  }
-};
+    // Assigns d to this together with computing lower and upper boundaries,
+    // where a boundary is a value half way between the number and its predecessor
+    // (lower) or successor (upper). The upper boundary is normalized and lower
+    // has the same exponent but may be not normalized.
+    template <typename Double> void assign_with_boundaries(Double d, fp &lower, fp &upper)
+    {
+      bool is_lower_closer = assign(d);
+      lower                = is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
+      // 1 in normalize accounts for the exponent shift above.
+      upper = normalize<1>(fp((f << 1) + 1, e - 1));
+      lower.f <<= lower.e - upper.e;
+      lower.e = upper.e;
+    }
 
-// Returns an fp number representing x - y. Result may not be normalized.
-inline fp operator-(fp x, fp y) {
-  FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
-  return fp(x.f - y.f, x.e);
-}
+    template <typename Double> void assign_float_with_boundaries(Double d, fp &lower, fp &upper)
+    {
+      assign(d);
+      constexpr int min_normal_e =
+          std::numeric_limits<float>::min_exponent - std::numeric_limits<double>::digits;
+      significand_type half_ulp =
+          1 << (std::numeric_limits<double>::digits - std::numeric_limits<float>::digits - 1);
+      if (min_normal_e > e)
+        half_ulp <<= min_normal_e - e;
+      upper = normalize<0>(fp(f + half_ulp, e));
+      lower = fp(f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
+      lower.f <<= lower.e - upper.e;
+      lower.e = upper.e;
+    }
+  };
+
+  inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
 
-// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
-// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be
-// normalized.
-FMT_FUNC fp operator*(fp x, fp y) {
-  int exp = x.e + y.e + 64;
+  // Returns an fp number representing x - y. Result may not be normalized.
+  inline fp operator-(fp x, fp y)
+  {
+    FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
+    return fp(x.f - y.f, x.e);
+  }
+
+  // Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
+  // with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be
+  // normalized.
+  FMT_FUNC fp operator*(fp x, fp y)
+  {
+    int exp = x.e + y.e + 64;
 #if FMT_USE_INT128
-  auto product = static_cast<__uint128_t>(x.f) * y.f;
-  auto f = static_cast<uint64_t>(product >> 64);
-  if ((static_cast<uint64_t>(product) & (1ULL << 63)) != 0) ++f;
-  return fp(f, exp);
+    auto product = static_cast<__uint128_t>(x.f) * y.f;
+    auto f       = static_cast<uint64_t>(product >> 64);
+    if ((static_cast<uint64_t>(product) & (1ULL << 63)) != 0)
+      ++f;
+    return fp(f, exp);
 #else
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = x.f >> 32, b = x.f & mask;
-  uint64_t c = y.f >> 32, d = y.f & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), exp);
+    // Multiply 32-bit parts of significands.
+    uint64_t mask = (1ULL << 32) - 1;
+    uint64_t a = x.f >> 32, b = x.f & mask;
+    uint64_t c = y.f >> 32, d = y.f & mask;
+    uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+    // Compute mid 64-bit of result and round.
+    uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+    return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), exp);
 #endif
-}
-
-// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its
-// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 28.
-FMT_FUNC fp get_cached_power(int min_exponent, int& pow10_exponent) {
-  const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
-  int index = static_cast<int>(
-      std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between 2 consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return fp(data::pow10_significands[index], data::pow10_exponents[index]);
-}
+  }
 
-enum round_direction { unknown, up, down };
-
-// Given the divisor (normally a power of 10), the remainder = v % divisor for
-// some number v and the error, returns whether v should be rounded up, down, or
-// whether the rounding direction can't be determined due to error.
-// error should be less than divisor / 2.
-inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
-                                           uint64_t error) {
-  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
-  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
-  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
-  // Round down if (remainder + error) * 2 <= divisor.
-  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
-    return down;
-  // Round up if (remainder - error) * 2 >= divisor.
-  if (remainder >= error &&
-      remainder - error >= divisor - (remainder - error)) {
-    return up;
+  // Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
+  // (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
+  FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent)
+  {
+    const uint64_t one_over_log2_10 = 0x4d104d42; // round(pow(2, 32) / log2(10))
+    int            index            = static_cast<int>(
+        static_cast<int64_t>((min_exponent + fp::significand_size - 1) * one_over_log2_10 +
+                             ((uint64_t(1) << 32) - 1) // ceil
+                             ) >>
+        32 // arithmetic shift
+    );
+    // Decimal exponent of the first (smallest) cached power of 10.
+    const int first_dec_exp = -348;
+    // Difference between 2 consecutive decimal exponents in cached powers of 10.
+    const int dec_exp_step = 8;
+    index                  = (index - first_dec_exp - 1) / dec_exp_step + 1;
+    pow10_exponent         = first_dec_exp + index * dec_exp_step;
+    return fp(data::pow10_significands[index], data::pow10_exponents[index]);
   }
-  return unknown;
-}
 
-namespace digits {
-enum result {
-  more,  // Generate more digits.
-  done,  // Done generating digits.
-  error  // Digit generation cancelled due to an error.
-};
-}
+  // A simple accumulator to hold the sums of terms in bigint::square if uint128_t
+  // is not available.
+  struct accumulator
+  {
+    uint64_t lower;
+    uint64_t upper;
+
+    accumulator() : lower(0), upper(0) {}
+    explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
+
+    void operator+=(uint64_t n)
+    {
+      lower += n;
+      if (lower < n)
+        ++upper;
+    }
+    void operator>>=(int shift)
+    {
+      assert(shift == 32);
+      (void)shift;
+      lower = (upper << 32) | (lower >> 32);
+      upper >>= 32;
+    }
+  };
 
-// Generates output using the Grisu digit-gen algorithm.
-// error: the size of the region (lower, upper) outside of which numbers
-// definitely do not round to value (Delta in Grisu3).
-template <typename Handler>
-digits::result grisu_gen_digits(fp value, uint64_t error, int& exp,
-                                Handler& handler) {
-  fp one(1ull << -value.e, value.e);
-  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
-  // zero because it contains a product of two 64-bit numbers with MSB set (due
-  // to normalization) - 1, shifted right by at most 60 bits.
-  uint32_t integral = static_cast<uint32_t>(value.f >> -one.e);
-  FMT_ASSERT(integral != 0, "");
-  FMT_ASSERT(integral == value.f >> -one.e, "");
-  // The fractional part of scaled value (p2 in Grisu) c = value % one.
-  uint64_t fractional = value.f & (one.f - 1);
-  exp = count_digits(integral);  // kappa in Grisu.
-  // Divide by 10 to prevent overflow.
-  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
-                                 value.f / 10, error * 10, exp);
-  if (result != digits::more) return result;
-  // Generate digits for the integral part. This can produce up to 10 digits.
-  do {
-    uint32_t digit = 0;
-    // This optimization by miloyip reduces the number of integer divisions by
-    // one per iteration.
-    switch (exp) {
-    case 10:
-      digit = integral / 1000000000;
-      integral %= 1000000000;
-      break;
-    case 9:
-      digit = integral / 100000000;
-      integral %= 100000000;
-      break;
-    case 8:
-      digit = integral / 10000000;
-      integral %= 10000000;
-      break;
-    case 7:
-      digit = integral / 1000000;
-      integral %= 1000000;
-      break;
-    case 6:
-      digit = integral / 100000;
-      integral %= 100000;
-      break;
-    case 5:
-      digit = integral / 10000;
-      integral %= 10000;
-      break;
-    case 4:
-      digit = integral / 1000;
-      integral %= 1000;
-      break;
-    case 3:
-      digit = integral / 100;
-      integral %= 100;
-      break;
-    case 2:
-      digit = integral / 10;
-      integral %= 10;
-      break;
-    case 1:
-      digit = integral;
-      integral = 0;
-      break;
-    default:
-      FMT_ASSERT(false, "invalid number of digits");
-    }
-    --exp;
-    uint64_t remainder =
-        (static_cast<uint64_t>(integral) << -one.e) + fractional;
-    result = handler.on_digit(static_cast<char>('0' + digit),
-                              data::powers_of_10_64[exp] << -one.e, remainder,
-                              error, exp, true);
-    if (result != digits::more) return result;
-  } while (exp > 0);
-  // Generate digits for the fractional part.
-  for (;;) {
-    fractional *= 10;
-    error *= 10;
-    char digit =
-        static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
-    fractional &= one.f - 1;
-    --exp;
-    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
-    if (result != digits::more) return result;
-  }
-}
+  class bigint
+  {
+  private:
+    // A bigint is stored as an array of bigits (big digits), with bigit at index
+    // 0 being the least significant one.
+    using bigit        = uint32_t;
+    using double_bigit = uint64_t;
+    enum { bigits_capacity = 32 };
+    basic_memory_buffer<bigit, bigits_capacity> bigits_;
+    int                                         exp_;
+
+    static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
+
+    friend struct formatter<bigint>;
+
+    void subtract_bigits(int index, bigit other, bigit &borrow)
+    {
+      auto result    = static_cast<double_bigit>(bigits_[index]) - other - borrow;
+      bigits_[index] = static_cast<bigit>(result);
+      borrow         = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
+    }
 
-// The fixed precision digit handler.
-struct fixed_handler {
-  char* buf;
-  int size;
-  int precision;
-  int exp10;
-  bool fixed;
-
-  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
-                          int& exp) {
-    // Non-fixed formats require at least one digit and no precision adjustment.
-    if (!fixed) return digits::more;
-    // Adjust fixed precision by exponent because it is relative to decimal
-    // point.
-    precision += exp + exp10;
-    // Check if precision is satisfied just by leading zeros, e.g.
-    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
-    if (precision > 0) return digits::more;
-    if (precision < 0) return digits::done;
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir == unknown) return digits::error;
-    buf[size++] = dir == up ? '1' : '0';
-    return digits::done;
-  }
+    void remove_leading_zeros()
+    {
+      int num_bigits = static_cast<int>(bigits_.size()) - 1;
+      while (num_bigits > 0 && bigits_[num_bigits] == 0)
+        --num_bigits;
+      bigits_.resize(num_bigits + 1);
+    }
 
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int, bool integral) {
-    FMT_ASSERT(remainder < divisor, "");
-    buf[size++] = digit;
-    if (size < precision) return digits::more;
-    if (!integral) {
-      // Check if error * 2 < divisor with overflow prevention.
-      // The check is not needed for the integral part because error = 1
-      // and divisor > (1 << 32) there.
-      if (error >= divisor || error >= divisor - error) return digits::error;
-    } else {
-      FMT_ASSERT(error == 1 && divisor > 2, "");
-    }
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir != up) return dir == down ? digits::done : digits::error;
-    ++buf[size - 1];
-    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
-      buf[i] = '0';
-      ++buf[i - 1];
-    }
-    if (buf[0] > '9') {
-      buf[0] = '1';
-      buf[size++] = '0';
-    }
-    return digits::done;
-  }
-};
+    // Computes *this -= other assuming aligned bigints and *this >= other.
+    void subtract_aligned(const bigint &other)
+    {
+      FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
+      FMT_ASSERT(compare(*this, other) >= 0, "");
+      bigit borrow = 0;
+      int   i      = other.exp_ - exp_;
+      for (int j = 0, n = static_cast<int>(other.bigits_.size()); j != n; ++i, ++j) {
+        subtract_bigits(i, other.bigits_[j], borrow);
+      }
+      while (borrow > 0)
+        subtract_bigits(i, 0, borrow);
+      remove_leading_zeros();
+    }
+
+    void multiply(uint32_t value)
+    {
+      const double_bigit wide_value = value;
+      bigit              carry      = 0;
+      for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+        double_bigit result = bigits_[i] * wide_value + carry;
+        bigits_[i]          = static_cast<bigit>(result);
+        carry               = static_cast<bigit>(result >> bigit_bits);
+      }
+      if (carry != 0)
+        bigits_.push_back(carry);
+    }
+
+    void multiply(uint64_t value)
+    {
+      const bigit        mask  = ~bigit(0);
+      const double_bigit lower = value & mask;
+      const double_bigit upper = value >> bigit_bits;
+      double_bigit       carry = 0;
+      for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+        double_bigit result = bigits_[i] * lower + (carry & mask);
+        carry               = bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
+        bigits_[i]          = static_cast<bigit>(result);
+      }
+      while (carry != 0) {
+        bigits_.push_back(carry & mask);
+        carry >>= bigit_bits;
+      }
+    }
+
+  public:
+    bigint() : exp_(0) {}
+    explicit bigint(uint64_t n) { assign(n); }
+    ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
+
+    bigint(const bigint &) = delete;
+    void operator=(const bigint &) = delete;
 
-// The shortest representation digit handler.
-template <int GRISU_VERSION> struct grisu_shortest_handler {
-  char* buf;
-  int size;
-  // Distance between scaled value and upper bound (wp_W in Grisu3).
-  uint64_t diff;
+    void assign(const bigint &other)
+    {
+      bigits_.resize(other.bigits_.size());
+      auto data = other.bigits_.data();
+      std::copy(data, data + other.bigits_.size(), bigits_.data());
+      exp_ = other.exp_;
+    }
+
+    void assign(uint64_t n)
+    {
+      int num_bigits = 0;
+      do {
+        bigits_[num_bigits++] = n & ~bigit(0);
+        n >>= bigit_bits;
+      } while (n != 0);
+      bigits_.resize(num_bigits);
+      exp_ = 0;
+    }
+
+    int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
+
+    bigint &operator<<=(int shift)
+    {
+      assert(shift >= 0);
+      exp_ += shift / bigit_bits;
+      shift %= bigit_bits;
+      if (shift == 0)
+        return *this;
+      bigit carry = 0;
+      for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+        bigit c    = bigits_[i] >> (bigit_bits - shift);
+        bigits_[i] = (bigits_[i] << shift) + carry;
+        carry      = c;
+      }
+      if (carry != 0)
+        bigits_.push_back(carry);
+      return *this;
+    }
+
+    template <typename Int> bigint &operator*=(Int value)
+    {
+      FMT_ASSERT(value > 0, "");
+      multiply(uint32_or_64_or_128_t<Int>(value));
+      return *this;
+    }
+
+    friend int compare(const bigint &lhs, const bigint &rhs)
+    {
+      int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
+      if (num_lhs_bigits != num_rhs_bigits)
+        return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
+      int i   = static_cast<int>(lhs.bigits_.size()) - 1;
+      int j   = static_cast<int>(rhs.bigits_.size()) - 1;
+      int end = i - j;
+      if (end < 0)
+        end = 0;
+      for (; i >= end; --i, --j) {
+        bigit lhs_bigit = lhs.bigits_[i], rhs_bigit = rhs.bigits_[j];
+        if (lhs_bigit != rhs_bigit)
+          return lhs_bigit > rhs_bigit ? 1 : -1;
+      }
+      if (i != j)
+        return i > j ? 1 : -1;
+      return 0;
+    }
+
+    // Returns compare(lhs1 + lhs2, rhs).
+    friend int add_compare(const bigint &lhs1, const bigint &lhs2, const bigint &rhs)
+    {
+      int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
+      int num_rhs_bigits = rhs.num_bigits();
+      if (max_lhs_bigits + 1 < num_rhs_bigits)
+        return -1;
+      if (max_lhs_bigits > num_rhs_bigits)
+        return 1;
+      auto get_bigit = [](const bigint &n, int i) -> bigit {
+        return i >= n.exp_ && i < n.num_bigits() ? n.bigits_[i - n.exp_] : 0;
+      };
+      double_bigit borrow  = 0;
+      int          min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
+      for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
+        double_bigit sum       = static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
+        bigit        rhs_bigit = get_bigit(rhs, i);
+        if (sum > rhs_bigit + borrow)
+          return 1;
+        borrow = rhs_bigit + borrow - sum;
+        if (borrow > 1)
+          return -1;
+        borrow <<= bigit_bits;
+      }
+      return borrow != 0 ? -1 : 0;
+    }
+
+    // Assigns pow(10, exp) to this bigint.
+    void assign_pow10(int exp)
+    {
+      assert(exp >= 0);
+      if (exp == 0)
+        return assign(1);
+      // Find the top bit.
+      int bitmask = 1;
+      while (exp >= bitmask)
+        bitmask <<= 1;
+      bitmask >>= 1;
+      // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
+      // repeated squaring and multiplication.
+      assign(5);
+      bitmask >>= 1;
+      while (bitmask != 0) {
+        square();
+        if ((exp & bitmask) != 0)
+          *this *= 5;
+        bitmask >>= 1;
+      }
+      *this <<= exp; // Multiply by pow(2, exp) by shifting.
+    }
+
+    void square()
+    {
+      basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
+      int                                         num_bigits = static_cast<int>(bigits_.size());
+      int                                         num_result_bigits = 2 * num_bigits;
+      bigits_.resize(num_result_bigits);
+      using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
+      auto sum            = accumulator_t();
+      for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
+        // Compute bigit at position bigit_index of the result by adding
+        // cross-product terms n[i] * n[j] such that i + j == bigit_index.
+        for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
+          // Most terms are multiplied twice which can be optimized in the future.
+          sum += static_cast<double_bigit>(n[i]) * n[j];
+        }
+        bigits_[bigit_index] = static_cast<bigit>(sum);
+        sum >>= bits<bigit>::value; // Compute the carry.
+      }
+      // Do the same for the top half.
+      for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) {
+        for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
+          sum += static_cast<double_bigit>(n[i++]) * n[j--];
+        bigits_[bigit_index] = static_cast<bigit>(sum);
+        sum >>= bits<bigit>::value;
+      }
+      --num_result_bigits;
+      remove_leading_zeros();
+      exp_ *= 2;
+    }
 
-  digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
-    return digits::more;
+    // Divides this bignum by divisor, assigning the remainder to this and
+    // returning the quotient.
+    int divmod_assign(const bigint &divisor)
+    {
+      FMT_ASSERT(this != &divisor, "");
+      if (compare(*this, divisor) < 0)
+        return 0;
+      int num_bigits = static_cast<int>(bigits_.size());
+      FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1] != 0, "");
+      int exp_difference = exp_ - divisor.exp_;
+      if (exp_difference > 0) {
+        // Align bigints by adding trailing zeros to simplify subtraction.
+        bigits_.resize(num_bigits + exp_difference);
+        for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
+          bigits_[j] = bigits_[i];
+        std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+        exp_ -= exp_difference;
+      }
+      int quotient = 0;
+      do {
+        subtract_aligned(divisor);
+        ++quotient;
+      } while (compare(*this, divisor) >= 0);
+      return quotient;
+    }
+  };
+
+  enum round_direction { unknown, up, down };
+
+  // Given the divisor (normally a power of 10), the remainder = v % divisor for
+  // some number v and the error, returns whether v should be rounded up, down, or
+  // whether the rounding direction can't be determined due to error.
+  // error should be less than divisor / 2.
+  inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder, uint64_t error)
+  {
+    FMT_ASSERT(remainder < divisor, "");     // divisor - remainder won't overflow.
+    FMT_ASSERT(error < divisor, "");         // divisor - error won't overflow.
+    FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow.
+    // Round down if (remainder + error) * 2 <= divisor.
+    if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
+      return down;
+    // Round up if (remainder - error) * 2 >= divisor.
+    if (remainder >= error && remainder - error >= divisor - (remainder - error)) {
+      return up;
+    }
+    return unknown;
   }
 
-  // Decrement the generated number approaching value from above.
-  void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
-             uint64_t error) {
-    while (
-        remainder < d && error - remainder >= divisor &&
-        (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
-      --buf[size - 1];
-      remainder += divisor;
+  namespace digits {
+    enum result {
+      more, // Generate more digits.
+      done, // Done generating digits.
+      error // Digit generation cancelled due to an error.
+    };
+  }
+
+  // Generates output using the Grisu digit-gen algorithm.
+  // error: the size of the region (lower, upper) outside of which numbers
+  // definitely do not round to value (Delta in Grisu3).
+  template <typename Handler>
+  digits::result grisu_gen_digits(fp value, uint64_t error, int &exp, Handler &handler)
+  {
+    const fp one(1ull << -value.e, value.e);
+    // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
+    // zero because it contains a product of two 64-bit numbers with MSB set (due
+    // to normalization) - 1, shifted right by at most 60 bits.
+    uint32_t integral = static_cast<uint32_t>(value.f >> -one.e);
+    FMT_ASSERT(integral != 0, "");
+    FMT_ASSERT(integral == value.f >> -one.e, "");
+    // The fractional part of scaled value (p2 in Grisu) c = value % one.
+    uint64_t fractional = value.f & (one.f - 1);
+    exp                 = count_digits(integral); // kappa in Grisu.
+    // Divide by 10 to prevent overflow.
+    auto result =
+        handler.on_start(data::powers_of_10_64[exp - 1] << -one.e, value.f / 10, error * 10, exp);
+    if (result != digits::more)
+      return result;
+    // Generate digits for the integral part. This can produce up to 10 digits.
+    do {
+      uint32_t digit           = 0;
+      auto     divmod_integral = [&](uint32_t divisor) {
+        digit = integral / divisor;
+        integral %= divisor;
+      };
+      // This optimization by Milo Yip reduces the number of integer divisions by
+      // one per iteration.
+      switch (exp) {
+      case 10: divmod_integral(1000000000); break;
+      case 9: divmod_integral(100000000); break;
+      case 8: divmod_integral(10000000); break;
+      case 7: divmod_integral(1000000); break;
+      case 6: divmod_integral(100000); break;
+      case 5: divmod_integral(10000); break;
+      case 4: divmod_integral(1000); break;
+      case 3: divmod_integral(100); break;
+      case 2: divmod_integral(10); break;
+      case 1:
+        digit    = integral;
+        integral = 0;
+        break;
+      default: FMT_ASSERT(false, "invalid number of digits");
+      }
+      --exp;
+      uint64_t remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
+      result             = handler.on_digit(static_cast<char>('0' + digit),
+                                data::powers_of_10_64[exp] << -one.e, remainder, error, exp, true);
+      if (result != digits::more)
+        return result;
+    } while (exp > 0);
+    // Generate digits for the fractional part.
+    for (;;) {
+      fractional *= 10;
+      error *= 10;
+      char digit = static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
+      fractional &= one.f - 1;
+      --exp;
+      result = handler.on_digit(digit, one.f, fractional, error, exp, false);
+      if (result != digits::more)
+        return result;
     }
   }
 
-  // Implements Grisu's round_weed.
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int exp, bool integral) {
-    buf[size++] = digit;
-    if (remainder >= error) return digits::more;
-    if (GRISU_VERSION != 3) {
-      uint64_t d = integral ? diff : diff * data::powers_of_10_64[-exp];
-      round(d, divisor, remainder, error);
+  // The fixed precision digit handler.
+  struct fixed_handler
+  {
+    char *buf;
+    int   size;
+    int   precision;
+    int   exp10;
+    bool  fixed;
+
+    digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error, int &exp)
+    {
+      // Non-fixed formats require at least one digit and no precision adjustment.
+      if (!fixed)
+        return digits::more;
+      // Adjust fixed precision by exponent because it is relative to decimal
+      // point.
+      precision += exp + exp10;
+      // Check if precision is satisfied just by leading zeros, e.g.
+      // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
+      if (precision > 0)
+        return digits::more;
+      if (precision < 0)
+        return digits::done;
+      auto dir = get_round_direction(divisor, remainder, error);
+      if (dir == unknown)
+        return digits::error;
+      buf[size++] = dir == up ? '1' : '0';
       return digits::done;
     }
-    uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
-    uint64_t up = (diff - 1) * unit;  // wp_Wup
-    round(up, divisor, remainder, error);
-    uint64_t down = (diff + 1) * unit;  // wp_Wdown
-    if (remainder < down && error - remainder >= divisor &&
-        (remainder + divisor < down ||
-         down - remainder > remainder + divisor - down)) {
-      return digits::error;
-    }
-    return 2 * unit <= remainder && remainder <= error - 4 * unit
-               ? digits::done
-               : digits::error;
-  }
-};
 
-template <typename Double,
-          enable_if_t<(sizeof(Double) == sizeof(uint64_t)), int>>
-FMT_API bool grisu_format(Double value, buffer<char>& buf, int precision,
-                          unsigned options, int& exp) {
-  FMT_ASSERT(value >= 0, "value is negative");
-  bool fixed = (options & grisu_options::fixed) != 0;
-  if (value <= 0) {  // <= instead of == to silence a warning.
-    if (precision <= 0 || !fixed) {
-      exp = 0;
-      buf.push_back('0');
-    } else {
-      exp = -precision;
-      buf.resize(precision);
-      std::uninitialized_fill_n(buf.data(), precision, '0');
+    digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error, int,
+                            bool integral)
+    {
+      FMT_ASSERT(remainder < divisor, "");
+      buf[size++] = digit;
+      if (size < precision)
+        return digits::more;
+      if (!integral) {
+        // Check if error * 2 < divisor with overflow prevention.
+        // The check is not needed for the integral part because error = 1
+        // and divisor > (1 << 32) there.
+        if (error >= divisor || error >= divisor - error)
+          return digits::error;
+      }
+      else {
+        FMT_ASSERT(error == 1 && divisor > 2, "");
+      }
+      auto dir = get_round_direction(divisor, remainder, error);
+      if (dir != up)
+        return dir == down ? digits::done : digits::error;
+      ++buf[size - 1];
+      for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
+        buf[i] = '0';
+        ++buf[i - 1];
+      }
+      if (buf[0] > '9') {
+        buf[0]      = '1';
+        buf[size++] = '0';
+      }
+      return digits::done;
     }
-    return true;
-  }
+  };
 
-  fp fp_value(value);
-  const int min_exp = -60;  // alpha in Grisu.
-  int cached_exp10 = 0;     // K in Grisu.
-  if (precision != -1) {
-    if (precision > 17) return false;
-    fp_value.normalize();
-    auto cached_pow = get_cached_power(
-        min_exp - (fp_value.e + fp::significand_size), cached_exp10);
-    fp_value = fp_value * cached_pow;
-    fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
-    if (grisu_gen_digits(fp_value, 1, exp, handler) == digits::error)
-      return false;
-    buf.resize(to_unsigned(handler.size));
-  } else {
-    fp lower, upper;  // w^- and w^+ in the Grisu paper.
-    fp_value.compute_boundaries(lower, upper);
-    // Find a cached power of 10 such that multiplying upper by it will bring
-    // the exponent in the range [min_exp, -32].
-    auto cached_pow = get_cached_power(  // \tilde{c}_{-k} in Grisu.
-        min_exp - (upper.e + fp::significand_size), cached_exp10);
-    fp_value.normalize();
-    fp_value = fp_value * cached_pow;
-    lower = lower * cached_pow;  // \tilde{M}^- in Grisu.
-    upper = upper * cached_pow;  // \tilde{M}^+ in Grisu.
-    assert(min_exp <= upper.e && upper.e <= -32);
-    auto result = digits::result();
-    int size = 0;
-    if ((options & grisu_options::grisu3) != 0) {
-      --lower.f;  // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
-      ++upper.f;  // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
-      // Numbers outside of (lower, upper) definitely do not round to value.
-      grisu_shortest_handler<3> handler{buf.data(), 0, (upper - fp_value).f};
-      result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
-      size = handler.size;
-    } else {
-      ++lower.f;  // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
-      --upper.f;  // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
-      grisu_shortest_handler<2> handler{buf.data(), 0, (upper - fp_value).f};
-      result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
-      size = handler.size;
-    }
-    if (result == digits::error) return false;
-    buf.resize(to_unsigned(size));
-  }
-  exp -= cached_exp10;
-  return true;
-}
+  // The shortest representation digit handler.
+  template <int GRISU_VERSION> struct grisu_shortest_handler
+  {
+    char *buf;
+    int   size;
+    // Distance between scaled value and upper bound (wp_W in Grisu3).
+    uint64_t diff;
+
+    digits::result on_start(uint64_t, uint64_t, uint64_t, int &) { return digits::more; }
+
+    // Decrement the generated number approaching value from above.
+    void round(uint64_t d, uint64_t divisor, uint64_t &remainder, uint64_t error)
+    {
+      while (remainder < d && error - remainder >= divisor &&
+             (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
+        --buf[size - 1];
+        remainder += divisor;
+      }
+    }
+
+    // Implements Grisu's round_weed.
+    digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error,
+                            int exp, bool integral)
+    {
+      buf[size++] = digit;
+      if (remainder >= error)
+        return digits::more;
+      if (const_check(GRISU_VERSION != 3)) {
+        uint64_t d = integral ? diff : diff * data::powers_of_10_64[-exp];
+        round(d, divisor, remainder, error);
+        return digits::done;
+      }
+      uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
+      uint64_t up   = (diff - 1) * unit; // wp_Wup
+      round(up, divisor, remainder, error);
+      uint64_t down = (diff + 1) * unit; // wp_Wdown
+      if (remainder < down && error - remainder >= divisor &&
+          (remainder + divisor < down || down - remainder > remainder + divisor - down)) {
+        return digits::error;
+      }
+      return 2 * unit <= remainder && remainder <= error - 4 * unit ? digits::done : digits::error;
+    }
+  };
 
-template <typename Double>
-char* sprintf_format(Double value, internal::buffer<char>& buf,
-                     sprintf_specs specs) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() != 0, "empty buffer");
-
-  // Build format string.
-  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.alt || !specs.type) *format_ptr++ = '#';
-  if (specs.precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
+  // Formats value using a variation of the Fixed-Precision Positive
+  // Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
+  // https://fmt.dev/p372-steele.pdf.
+  template <typename Double> void fallback_format(Double d, buffer<char> &buf, int &exp10)
+  {
+    bigint numerator;   // 2 * R in (FPP)^2.
+    bigint denominator; // 2 * S in (FPP)^2.
+    // lower and upper are differences between value and corresponding boundaries.
+    bigint  lower;           // (M^- in (FPP)^2).
+    bigint  upper_store;     // upper's value if different from lower.
+    bigint *upper = nullptr; // (M^+ in (FPP)^2).
+    fp      value;
+    // Shift numerator and denominator by an extra bit or two (if lower boundary
+    // is closer) to make lower and upper integers. This eliminates multiplication
+    // by 2 during later computations.
+    // TODO: handle float
+    int      shift       = value.assign(d) ? 2 : 1;
+    uint64_t significand = value.f << shift;
+    if (value.e >= 0) {
+      numerator.assign(significand);
+      numerator <<= value.e;
+      lower.assign(1);
+      lower <<= value.e;
+      if (shift != 1) {
+        upper_store.assign(1);
+        upper_store <<= value.e + 1;
+        upper = &upper_store;
+      }
+      denominator.assign_pow10(exp10);
+      denominator <<= 1;
+    }
+    else if (exp10 < 0) {
+      numerator.assign_pow10(-exp10);
+      lower.assign(numerator);
+      if (shift != 1) {
+        upper_store.assign(numerator);
+        upper_store <<= 1;
+        upper = &upper_store;
+      }
+      numerator *= significand;
+      denominator.assign(1);
+      denominator <<= shift - value.e;
+    }
+    else {
+      numerator.assign(significand);
+      denominator.assign_pow10(exp10);
+      denominator <<= shift - value.e;
+      lower.assign(1);
+      if (shift != 1) {
+        upper_store.assign(1ull << 1);
+        upper = &upper_store;
+      }
+    }
+    if (!upper)
+      upper = &lower;
+    // Invariant: value == (numerator / denominator) * pow(10, exp10).
+    bool  even       = (value.f & 1) == 0;
+    int   num_digits = 0;
+    char *data       = buf.data();
+    for (;;) {
+      int  digit = numerator.divmod_assign(denominator);
+      bool low   = compare(numerator, lower) - even < 0; // numerator <[=] lower.
+      // numerator + upper >[=] pow10:
+      bool high          = add_compare(numerator, *upper, denominator) + even > 0;
+      data[num_digits++] = static_cast<char>('0' + digit);
+      if (low || high) {
+        if (!low) {
+          ++data[num_digits - 1];
+        }
+        else if (high) {
+          int result = add_compare(numerator, numerator, denominator);
+          // Round half to even.
+          if (result > 0 || (result == 0 && (digit % 2) != 0))
+            ++data[num_digits - 1];
+        }
+        buf.resize(num_digits);
+        exp10 -= num_digits - 1;
+        return;
+      }
+      numerator *= 10;
+      lower *= 10;
+      if (upper != &lower)
+        *upper *= 10;
+    }
   }
-  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
-
-  char type = specs.type;
-
-  if (type == '%')
-    type = 'f';
-  else if (type == 0 || type == 'n')
-    type = 'g';
-#if FMT_MSC_VER
-  if (type == 'F') {
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
+
+  template <typename Double, enable_if_t<(sizeof(Double) == sizeof(uint64_t)), int>>
+  bool grisu_format(Double value, buffer<char> &buf, int precision, unsigned options, int &exp)
+  {
+    FMT_ASSERT(value >= 0, "value is negative");
+    const bool fixed = (options & grisu_options::fixed) != 0;
+    if (value <= 0) { // <= instead of == to silence a warning.
+      if (precision <= 0 || !fixed) {
+        exp = 0;
+        buf.push_back('0');
+      }
+      else {
+        exp = -precision;
+        buf.resize(to_unsigned(precision));
+        std::uninitialized_fill_n(buf.data(), precision, '0');
+      }
+      return true;
+    }
+
+    const int min_exp      = -60; // alpha in Grisu.
+    int       cached_exp10 = 0;   // K in Grisu.
+    if (precision != -1) {
+      if (precision > 17)
+        return false;
+      fp         fp_value(value);
+      fp         normalized = normalize(fp_value);
+      const auto cached_pow =
+          get_cached_power(min_exp - (normalized.e + fp::significand_size), cached_exp10);
+      normalized = normalized * cached_pow;
+      fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
+      if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
+        return false;
+      int num_digits = handler.size;
+      if (!fixed) {
+        // Remove trailing zeros.
+        while (num_digits > 0 && buf[num_digits - 1] == '0') {
+          --num_digits;
+          ++exp;
+        }
+      }
+      buf.resize(to_unsigned(num_digits));
+    }
+    else {
+      fp fp_value;
+      fp lower, upper; // w^- and w^+ in the Grisu paper.
+      if ((options & grisu_options::binary32) != 0)
+        fp_value.assign_float_with_boundaries(value, lower, upper);
+      else
+        fp_value.assign_with_boundaries(value, lower, upper);
+
+      // Find a cached power of 10 such that multiplying upper by it will bring
+      // the exponent in the range [min_exp, -32].
+      const auto cached_pow = get_cached_power( // \tilde{c}_{-k} in Grisu.
+          min_exp - (upper.e + fp::significand_size), cached_exp10);
+      fp         normalized = normalize(fp_value);
+      normalized            = normalized * cached_pow;
+      lower                 = lower * cached_pow; // \tilde{M}^- in Grisu.
+      upper                 = upper * cached_pow; // \tilde{M}^+ in Grisu.
+      assert(min_exp <= upper.e && upper.e <= -32);
+      auto result = digits::result();
+      int  size   = 0;
+      if ((options & grisu_options::grisu2) != 0) {
+        ++lower.f; // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
+        --upper.f; // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
+        grisu_shortest_handler<2> handler{buf.data(), 0, (upper - normalized).f};
+        result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
+        size   = handler.size;
+        assert(result != digits::error);
+      }
+      else {
+        --lower.f; // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
+        ++upper.f; // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
+        // Numbers outside of (lower, upper) definitely do not round to value.
+        grisu_shortest_handler<3> handler{buf.data(), 0, (upper - normalized).f};
+        result = grisu_gen_digits(upper, upper.f - lower.f, exp, handler);
+        size   = handler.size;
+        if (result == digits::error) {
+          exp = exp + size - cached_exp10 - 1;
+          fallback_format(value, buf, exp);
+          return true;
+        }
+      }
+      buf.resize(to_unsigned(size));
+    }
+    exp -= cached_exp10;
+    return true;
   }
-#endif
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  char* start = nullptr;
-  char* decimal_point_pos = nullptr;
-  for (;;) {
-    std::size_t buffer_size = buf.capacity();
-    start = &buf[0];
-    int result =
-        format_float(start, buffer_size, format, specs.precision, value);
-    if (result >= 0) {
-      unsigned n = internal::to_unsigned(result);
-      if (n < buf.capacity()) {
-        // Find the decimal point.
-        auto p = buf.data(), end = p + n;
-        if (*p == '+' || *p == '-') ++p;
-        if (specs.type != 'a' && specs.type != 'A') {
-          while (p < end && *p >= '0' && *p <= '9') ++p;
-          if (p < end && *p != 'e' && *p != 'E') {
-            decimal_point_pos = p;
-            if (!specs.type) {
-              // Keep only one trailing zero after the decimal point.
+
+  template <typename Double>
+  char *sprintf_format(Double value, internal::buffer<char> &buf, sprintf_specs specs)
+  {
+    // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+    FMT_ASSERT(buf.capacity() != 0, "empty buffer");
+
+    // Build format string.
+    enum { max_format_size = 10 }; // longest format: %#-*.*Lg
+    char  format[max_format_size];
+    char *format_ptr = format;
+    *format_ptr++    = '%';
+    if (specs.alt || !specs.type)
+      *format_ptr++ = '#';
+    if (specs.precision >= 0) {
+      *format_ptr++ = '.';
+      *format_ptr++ = '*';
+    }
+    if (std::is_same<Double, long double>::value)
+      *format_ptr++ = 'L';
+
+    char type = specs.type;
+
+    if (type == '%')
+      type = 'f';
+    else if (type == 0 || type == 'n')
+      type = 'g';
+    if (FMT_MSC_VER && type == 'F')
+      type = 'f'; // // MSVC's printf doesn't support 'F'.
+    *format_ptr++ = type;
+    *format_ptr   = '\0';
+
+    // Format using snprintf.
+    char *start             = nullptr;
+    char *decimal_point_pos = nullptr;
+    for (;;) {
+      std::size_t buffer_size = buf.capacity();
+      start                   = &buf[0];
+      int result              = format_float(start, buffer_size, format, specs.precision, value);
+      if (result >= 0) {
+        unsigned n = internal::to_unsigned(result);
+        if (n < buf.capacity()) {
+          // Find the decimal point.
+          auto p = buf.data(), end = p + n;
+          if (*p == '+' || *p == '-')
+            ++p;
+          if (specs.type != 'a' && specs.type != 'A') {
+            while (p < end && *p >= '0' && *p <= '9')
               ++p;
-              if (*p == '0') ++p;
-              while (p != end && *p >= '1' && *p <= '9') ++p;
-              char* where = p;
-              while (p != end && *p == '0') ++p;
-              if (p == end || *p < '0' || *p > '9') {
-                if (p != end) std::memmove(where, p, to_unsigned(end - p));
-                n -= static_cast<unsigned>(p - where);
+            if (p < end && *p != 'e' && *p != 'E') {
+              decimal_point_pos = p;
+              if (!specs.type) {
+                // Keep only one trailing zero after the decimal point.
+                ++p;
+                if (*p == '0')
+                  ++p;
+                while (p != end && *p >= '1' && *p <= '9')
+                  ++p;
+                char *where = p;
+                while (p != end && *p == '0')
+                  ++p;
+                if (p == end || *p < '0' || *p > '9') {
+                  if (p != end)
+                    std::memmove(where, p, to_unsigned(end - p));
+                  n -= static_cast<unsigned>(p - where);
+                }
               }
             }
           }
+          buf.resize(n);
+          break; // The buffer is large enough - continue with formatting.
         }
-        buf.resize(n);
-        break;  // The buffer is large enough - continue with formatting.
+        buf.reserve(n + 1);
+      }
+      else {
+        // If result is negative we ask to increase the capacity by at least 1,
+        // but as std::vector, the buffer grows exponentially.
+        buf.reserve(buf.capacity() + 1);
       }
-      buf.reserve(n + 1);
-    } else {
-      // If result is negative we ask to increase the capacity by at least 1,
-      // but as std::vector, the buffer grows exponentially.
-      buf.reserve(buf.capacity() + 1);
     }
+    return decimal_point_pos;
   }
-  return decimal_point_pos;
-}
-}  // namespace internal
+} // namespace internal
+
+template <> struct formatter<internal::bigint>
+{
+  format_parse_context::iterator parse(format_parse_context &ctx) { return ctx.begin(); }
+
+  format_context::iterator format(const internal::bigint &n, format_context &ctx)
+  {
+    auto out   = ctx.out();
+    bool first = true;
+    for (auto i = n.bigits_.size(); i > 0; --i) {
+      auto value = n.bigits_[i - 1];
+      if (first) {
+        out   = format_to(out, "{:x}", value);
+        first = false;
+        continue;
+      }
+      out = format_to(out, "{:08x}", value);
+    }
+    if (n.exp_ > 0)
+      out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
+    return out;
+  }
+};
 
 #if FMT_USE_WINDOWS_H
 
-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s)
+{
   static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
   if (s.size() > INT_MAX)
     FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
@@ -845,25 +1269,28 @@ FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
     return;
   }
 
-  int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(),
-                                   s_size, nullptr, 0);
-  if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
+  int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, nullptr, 0);
+  if (length == 0)
+    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_.resize(length + 1);
-  length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size,
-                               &buffer_[0], length);
-  if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
+  length =
+      MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
+  if (length == 0)
+    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_[length] = 0;
 }
 
-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
+FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s)
+{
   if (int error_code = convert(s)) {
-    FMT_THROW(windows_error(error_code,
-                            "cannot convert string from UTF-16 to UTF-8"));
+    FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8"));
   }
 }
 
-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
-  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
+FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s)
+{
+  if (s.size() > INT_MAX)
+    return ERROR_INVALID_PARAMETER;
   int s_size = static_cast<int>(s.size());
   if (s_size == 0) {
     // WideCharToMultiByte does not support zero length, handle separately.
@@ -872,38 +1299,38 @@ FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
     return 0;
   }
 
-  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
-                                   nullptr, nullptr);
-  if (length == 0) return GetLastError();
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0, nullptr, nullptr);
+  if (length == 0)
+    return GetLastError();
   buffer_.resize(length + 1);
-  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
-                               length, nullptr, nullptr);
-  if (length == 0) return GetLastError();
+  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, nullptr, nullptr);
+  if (length == 0)
+    return GetLastError();
   buffer_[length] = 0;
   return 0;
 }
 
-FMT_FUNC void windows_error::init(int err_code, string_view format_str,
-                                  format_args args) {
+FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args)
+{
   error_code_ = err_code;
   memory_buffer buffer;
   internal::format_windows_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error& base = *this;
-  base = std::runtime_error(to_string(buffer));
+  std::runtime_error &base = *this;
+  base                     = std::runtime_error(to_string(buffer));
 }
 
-FMT_FUNC void internal::format_windows_error(internal::buffer<char>& out,
-                                             int error_code,
-                                             string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
+FMT_FUNC void internal::format_windows_error(internal::buffer<char> &out, int error_code,
+                                             string_view message) FMT_NOEXCEPT
+{
+  FMT_TRY
+  {
     wmemory_buffer buf;
     buf.resize(inline_buffer_size);
     for (;;) {
-      wchar_t* system_message = &buf[0];
-      int result = FormatMessageW(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
-          error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
-          static_cast<uint32_t>(buf.size()), nullptr);
+      wchar_t *system_message = &buf[0];
+      int      result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                                  nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                                  system_message, static_cast<uint32_t>(buf.size()), nullptr);
       if (result != 0) {
         utf16_to_utf8 utf8_message;
         if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
@@ -916,7 +1343,7 @@ FMT_FUNC void internal::format_windows_error(internal::buffer<char>& out,
         break;
       }
       if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-        break;  // Can't get error message, report error code instead.
+        break; // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
   }
@@ -924,17 +1351,18 @@ FMT_FUNC void internal::format_windows_error(internal::buffer<char>& out,
   format_error_code(out, error_code, message);
 }
 
-#endif  // FMT_USE_WINDOWS_H
+#endif // FMT_USE_WINDOWS_H
 
-FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
-                                  string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
+FMT_FUNC void format_system_error(internal::buffer<char> &out, int error_code,
+                                  string_view message) FMT_NOEXCEPT
+{
+  FMT_TRY
+  {
     memory_buffer buf;
     buf.resize(inline_buffer_size);
     for (;;) {
-      char* system_message = &buf[0];
-      int result =
-          internal::safe_strerror(error_code, system_message, buf.size());
+      char *system_message = &buf[0];
+      int   result         = internal::safe_strerror(error_code, system_message, buf.size());
       if (result == 0) {
         internal::writer w(out);
         w.write(message);
@@ -943,7 +1371,7 @@ FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
         return;
       }
       if (result != ERANGE)
-        break;  // Can't get error message, report error code instead.
+        break; // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
   }
@@ -951,30 +1379,32 @@ FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
   format_error_code(out, error_code, message);
 }
 
-FMT_FUNC void internal::error_handler::on_error(const char* message) {
+FMT_FUNC void internal::error_handler::on_error(const char *message)
+{
   FMT_THROW(format_error(message));
 }
 
-FMT_FUNC void report_system_error(int error_code,
-                                  fmt::string_view message) FMT_NOEXCEPT {
+FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+{
   report_error(format_system_error, error_code, message);
 }
 
 #if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(int error_code,
-                                   fmt::string_view message) FMT_NOEXCEPT {
+FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+{
   report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
+{
   memory_buffer buffer;
-  internal::vformat_to(buffer, format_str,
-                       basic_format_args<buffer_context<char>>(args));
+  internal::vformat_to(buffer, format_str, basic_format_args<buffer_context<char>>(args));
   internal::fwrite_fully(buffer.data(), 1, buffer.size(), f);
 }
 
-FMT_FUNC void vprint(std::FILE* f, wstring_view format_str, wformat_args args) {
+FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args)
+{
   wmemory_buffer buffer;
   internal::vformat_to(buffer, format_str, args);
   buffer.push_back(L'\0');
@@ -983,18 +1413,17 @@ FMT_FUNC void vprint(std::FILE* f, wstring_view format_str, wformat_args args) {
   }
 }
 
-FMT_FUNC void vprint(string_view format_str, format_args args) {
-  vprint(stdout, format_str, args);
-}
+FMT_FUNC void vprint(string_view format_str, format_args args) { vprint(stdout, format_str, args); }
 
-FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
+FMT_FUNC void vprint(wstring_view format_str, wformat_args args)
+{
   vprint(stdout, format_str, args);
 }
 
 FMT_END_NAMESPACE
 
 #ifdef _MSC_VER
-#  pragma warning(pop)
+#pragma warning(pop)
 #endif
 
-#endif  // FMT_FORMAT_INL_H_
+#endif // FMT_FORMAT_INL_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/format.h b/packages/seacas/libraries/suplib_cpp/fmt/format.h
index acc39c40614a..483252d30a8d 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/format.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/format.h
@@ -46,454 +46,475 @@
 #include "core.h"
 
 #ifdef __clang__
-#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
 #else
-#  define FMT_CLANG_VERSION 0
+#define FMT_CLANG_VERSION 0
 #endif
 
 #ifdef __INTEL_COMPILER
-#  define FMT_ICC_VERSION __INTEL_COMPILER
+#define FMT_ICC_VERSION __INTEL_COMPILER
 #elif defined(__ICL)
-#  define FMT_ICC_VERSION __ICL
+#define FMT_ICC_VERSION __ICL
 #else
-#  define FMT_ICC_VERSION 0
+#define FMT_ICC_VERSION 0
 #endif
 
 #ifdef __NVCC__
-#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
+#define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
 #else
-#  define FMT_CUDA_VERSION 0
+#define FMT_CUDA_VERSION 0
 #endif
 
 #ifdef __has_builtin
-#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#define FMT_HAS_BUILTIN(x) __has_builtin(x)
 #else
-#  define FMT_HAS_BUILTIN(x) 0
+#define FMT_HAS_BUILTIN(x) 0
 #endif
 
 #ifndef FMT_THROW
-#  if FMT_EXCEPTIONS
-#    if FMT_MSC_VER
+#if FMT_EXCEPTIONS
+#if FMT_MSC_VER
 FMT_BEGIN_NAMESPACE
 namespace internal {
-template <typename Exception> inline void do_throw(const Exception& x) {
-  // Silence unreachable code warnings in MSVC because these are nearly
-  // impossible to fix in a generic code.
-  volatile bool b = true;
-  if (b) throw x;
-}
-}  // namespace internal
+  template <typename Exception> inline void do_throw(const Exception &x)
+  {
+    // Silence unreachable code warnings in MSVC because these are nearly
+    // impossible to fix in a generic code.
+    volatile bool b = true;
+    if (b)
+      throw x;
+  }
+} // namespace internal
 FMT_END_NAMESPACE
-#      define FMT_THROW(x) fmt::internal::do_throw(x)
-#    else
-#      define FMT_THROW(x) throw x
-#    endif
-#  else
-#    define FMT_THROW(x)              \
-      do {                            \
-        static_cast<void>(sizeof(x)); \
-        assert(false);                \
-      } while (false)
-#  endif
+#define FMT_THROW(x) fmt::internal::do_throw(x)
+#else
+#define FMT_THROW(x) throw x
+#endif
+#else
+#define FMT_THROW(x)                                                                               \
+  do {                                                                                             \
+    static_cast<void>(sizeof(x));                                                                  \
+    assert(false);                                                                                 \
+  } while (false)
+#endif
 #endif
 
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
-#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 ||      \
-       FMT_MSC_VER >= 1900) &&                                              \
-      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
-       FMT_CUDA_VERSION >= 700)
-#    define FMT_USE_USER_DEFINED_LITERALS 1
-#  else
-#    define FMT_USE_USER_DEFINED_LITERALS 0
-#  endif
+#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) &&       \
+    (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || FMT_CUDA_VERSION >= 700)
+#define FMT_USE_USER_DEFINED_LITERALS 1
+#else
+#define FMT_USE_USER_DEFINED_LITERALS 0
+#endif
 #endif
 
 #ifndef FMT_USE_UDL_TEMPLATE
 // EDG front end based compilers (icc, nvcc) do not support UDL templates yet
 // and GCC 9 warns about them.
-#  if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
-      FMT_CUDA_VERSION == 0 &&                                 \
-      ((FMT_GCC_VERSION >= 600 && FMT_GCC_VERSION <= 900 &&    \
-        __cplusplus >= 201402L) ||                             \
-       FMT_CLANG_VERSION >= 304)
-#    define FMT_USE_UDL_TEMPLATE 1
-#  else
-#    define FMT_USE_UDL_TEMPLATE 0
-#  endif
-#endif
-
-#ifdef FMT_USE_INT128
-// Do nothing.
-#elif defined(__SIZEOF_INT128__)
-#  define FMT_USE_INT128 1
+#if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && FMT_CUDA_VERSION == 0 &&              \
+    ((FMT_GCC_VERSION >= 600 && FMT_GCC_VERSION <= 900 && __cplusplus >= 201402L) ||               \
+     FMT_CLANG_VERSION >= 304)
+#define FMT_USE_UDL_TEMPLATE 1
 #else
-#  define FMT_USE_INT128 0
+#define FMT_USE_UDL_TEMPLATE 0
+#endif
 #endif
 
 // __builtin_clz is broken in clang with Microsoft CodeGen:
 // https://github.com/fmtlib/fmt/issues/519
 #if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
 #endif
 #if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
 #endif
 
 // Some compilers masquerade as both MSVC and GCC-likes or otherwise support
 // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
 // MSVC intrinsics if the clz and clzll builtins are not available.
 #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
-#  include <intrin.h>  // _BitScanReverse, _BitScanReverse64
+#include <intrin.h> // _BitScanReverse, _BitScanReverse64
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#  ifndef __clang__
-#    pragma intrinsic(_BitScanReverse)
-#  endif
-inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
-
-  assert(x != 0);
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 31 - r;
-}
-#  define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
-
-#  if defined(_WIN64) && !defined(__clang__)
-#    pragma intrinsic(_BitScanReverse64)
-#  endif
-
-inline uint32_t clzll(uint64_t x) {
-  unsigned long r = 0;
-#  ifdef _WIN64
-  _BitScanReverse64(&r, x);
-#  else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);
-
-  // Scan the low 32 bits.
-  _BitScanReverse(&r, static_cast<uint32_t>(x));
-#  endif
-
-  assert(x != 0);
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 63 - r;
-}
-#  define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-}  // namespace internal
+#ifndef __clang__
+#pragma intrinsic(_BitScanReverse)
+#endif
+  inline uint32_t clz(uint32_t x)
+  {
+    unsigned long r = 0;
+    _BitScanReverse(&r, x);
+
+    assert(x != 0);
+    // Static analysis complains about using uninitialized data
+    // "r", but the only way that can happen is if "x" is 0,
+    // which the callers guarantee to not happen.
+#pragma warning(suppress : 6102)
+    return 31 - r;
+  }
+#define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
+
+#if defined(_WIN64) && !defined(__clang__)
+#pragma intrinsic(_BitScanReverse64)
+#endif
+
+  inline uint32_t clzll(uint64_t x)
+  {
+    unsigned long r = 0;
+#ifdef _WIN64
+    _BitScanReverse64(&r, x);
+#else
+    // Scan the high 32 bits.
+    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+      return 63 - (r + 32);
+
+    // Scan the low 32 bits.
+    _BitScanReverse(&r, static_cast<uint32_t>(x));
+#endif
+
+    assert(x != 0);
+    // Static analysis complains about using uninitialized data
+    // "r", but the only way that can happen is if "x" is 0,
+    // which the callers guarantee to not happen.
+#pragma warning(suppress : 6102)
+    return 63 - r;
+  }
+#define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
+} // namespace internal
 FMT_END_NAMESPACE
 #endif
 
+#ifndef FMT_NUMERIC_ALIGN
+#define FMT_NUMERIC_ALIGN 1
+#endif
+
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-// A fallback implementation of uintptr_t for systems that lack it.
-struct fallback_uintptr {
-  unsigned char value[sizeof(void*)];
-};
+  // A helper function to suppress bogus "conditional expression is constant"
+  // warnings.
+  template <typename T> inline T const_check(T value) { return value; }
+
+  // A fallback implementation of uintptr_t for systems that lack it.
+  struct fallback_uintptr
+  {
+    unsigned char value[sizeof(void *)];
+  };
 #ifdef UINTPTR_MAX
-using uintptr_t = ::uintptr_t;
+  using uintptr_t = ::uintptr_t;
 #else
-using uintptr_t = fallback_uintptr;
+  using uintptr_t                         = fallback_uintptr;
 #endif
 
-// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
-// undefined behavior (e.g. due to type aliasing).
-// Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template <typename Dest, typename Source>
-inline Dest bit_cast(const Source& source) {
-  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-  Dest dest;
-  std::memcpy(&dest, &source, sizeof(dest));
-  return dest;
-}
-
-// An approximation of iterator_t for pre-C++20 systems.
-template <typename T>
-using iterator_t = decltype(std::begin(std::declval<T&>()));
-
-// Detect the iterator category of *any* given type in a SFINAE-friendly way.
-// Unfortunately, older implementations of std::iterator_traits are not safe
-// for use in a SFINAE-context.
-template <typename It, typename Enable = void>
-struct iterator_category : std::false_type {};
+  // An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
+  // undefined behavior (e.g. due to type aliasing).
+  // Example: uint64_t d = bit_cast<uint64_t>(2.718);
+  template <typename Dest, typename Source> inline Dest bit_cast(const Source &source)
+  {
+    static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
+    Dest dest;
+    std::memcpy(&dest, &source, sizeof(dest));
+    return dest;
+  }
+
+  // Returns the largest possible value for type T. Same as
+  // std::numeric_limits<T>::max() but shorter and not affected by the max macro.
+  template <typename T> constexpr T max_value() { return (std::numeric_limits<T>::max)(); }
+
+  // An approximation of iterator_t for pre-C++20 systems.
+  template <typename T> using iterator_t = decltype(std::begin(std::declval<T &>()));
+
+  // Detect the iterator category of *any* given type in a SFINAE-friendly way.
+  // Unfortunately, older implementations of std::iterator_traits are not safe
+  // for use in a SFINAE-context.
+  template <typename It, typename Enable = void> struct iterator_category : std::false_type
+  {
+  };
 
-template <typename T> struct iterator_category<T*> {
-  using type = std::random_access_iterator_tag;
-};
+  template <typename T> struct iterator_category<T *>
+  {
+    using type = std::random_access_iterator_tag;
+  };
 
-template <typename It>
-struct iterator_category<It, void_t<typename It::iterator_category>> {
-  using type = typename It::iterator_category;
-};
+  template <typename It> struct iterator_category<It, void_t<typename It::iterator_category>>
+  {
+    using type = typename It::iterator_category;
+  };
 
-// Detect if *any* given type models the OutputIterator concept.
-template <typename It> class is_output_iterator {
-  // Check for mutability because all iterator categories derived from
-  // std::input_iterator_tag *may* also meet the requirements of an
-  // OutputIterator, thereby falling into the category of 'mutable iterators'
-  // [iterator.requirements.general] clause 4. The compiler reveals this
-  // property only at the point of *actually dereferencing* the iterator!
-  template <typename U>
-  static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
-  template <typename U> static char& test(std::output_iterator_tag);
-  template <typename U> static const char& test(...);
-
-  using type = decltype(test<It>(typename iterator_category<It>::type{}));
-
- public:
-  static const bool value = !std::is_const<remove_reference_t<type>>::value;
-};
+  // Detect if *any* given type models the OutputIterator concept.
+  template <typename It> class is_output_iterator
+  {
+    // Check for mutability because all iterator categories derived from
+    // std::input_iterator_tag *may* also meet the requirements of an
+    // OutputIterator, thereby falling into the category of 'mutable iterators'
+    // [iterator.requirements.general] clause 4. The compiler reveals this
+    // property only at the point of *actually dereferencing* the iterator!
+    template <typename U> static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
+    template <typename U> static char &                         test(std::output_iterator_tag);
+    template <typename U> static const char &                   test(...);
+
+    using type = decltype(test<It>(typename iterator_category<It>::type{}));
+
+  public:
+    static const bool value = !std::is_const<remove_reference_t<type>>::value;
+  };
 
-// A workaround for std::string not having mutable data() until C++17.
-template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
-  return &s[0];
-}
-template <typename Container>
-inline typename Container::value_type* get_data(Container& c) {
-  return c.data();
-}
+  // A workaround for std::string not having mutable data() until C++17.
+  template <typename Char> inline Char *get_data(std::basic_string<Char> &s) { return &s[0]; }
+  template <typename Container> inline typename Container::value_type *get_data(Container &c)
+  {
+    return c.data();
+  }
 
 #ifdef _SECURE_SCL
-// Make a checked iterator to avoid MSVC warnings.
-template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
-template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
-  return {p, size};
-}
+  // Make a checked iterator to avoid MSVC warnings.
+  template <typename T> using checked_ptr = stdext::checked_array_iterator<T *>;
+  template <typename T> checked_ptr<T> make_checked(T *p, std::size_t size) { return {p, size}; }
 #else
-template <typename T> using checked_ptr = T*;
-template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
+  template <typename T> using checked_ptr = T *;
+  template <typename T> inline T *make_checked(T *p, std::size_t) { return p; }
 #endif
 
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline checked_ptr<typename Container::value_type> reserve(
-    std::back_insert_iterator<Container>& it, std::size_t n) {
-  Container& c = get_container(it);
-  std::size_t size = c.size();
-  c.resize(size + n);
-  return make_checked(get_data(c) + size, n);
-}
-
-template <typename Iterator>
-inline Iterator& reserve(Iterator& it, std::size_t) {
-  return it;
-}
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-template <typename T> class counting_iterator {
- private:
-  std::size_t count_;
-  mutable T blackhole_;
+  template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+  inline checked_ptr<typename Container::value_type>
+  reserve(std::back_insert_iterator<Container> &it, std::size_t n)
+  {
+    Container & c    = get_container(it);
+    std::size_t size = c.size();
+    c.resize(size + n);
+    return make_checked(get_data(c) + size, n);
+  }
+
+  template <typename Iterator> inline Iterator &reserve(Iterator &it, std::size_t) { return it; }
+
+  // An output iterator that counts the number of objects written to it and
+  // discards them.
+  class counting_iterator
+  {
+  private:
+    std::size_t count_;
+
+  public:
+    using iterator_category = std::output_iterator_tag;
+    using difference_type   = std::ptrdiff_t;
+    using pointer           = void;
+    using reference         = void;
+    using _Unchecked_type   = counting_iterator; // Mark iterator as checked.
+
+    struct value_type
+    {
+      template <typename T> void operator=(const T &) {}
+    };
 
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using difference_type = std::ptrdiff_t;
-  using pointer = T*;
-  using reference = T&;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+    counting_iterator() : count_(0) {}
 
-  counting_iterator() : count_(0) {}
+    std::size_t count() const { return count_; }
 
-  std::size_t count() const { return count_; }
+    counting_iterator &operator++()
+    {
+      ++count_;
+      return *this;
+    }
 
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
+    counting_iterator operator++(int)
+    {
+      auto it = *this;
+      ++*this;
+      return it;
+    }
 
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
+    value_type operator*() const { return {}; }
+  };
 
-  T& operator*() const { return blackhole_; }
-};
+  template <typename OutputIt> class truncating_iterator_base
+  {
+  protected:
+    OutputIt    out_;
+    std::size_t limit_;
+    std::size_t count_;
 
-template <typename OutputIt> class truncating_iterator_base {
- protected:
-  OutputIt out_;
-  std::size_t limit_;
-  std::size_t count_;
-
-  truncating_iterator_base(OutputIt out, std::size_t limit)
-      : out_(out), limit_(limit), count_(0) {}
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = void;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
-
-  OutputIt base() const { return out_; }
-  std::size_t count() const { return count_; }
-};
+    truncating_iterator_base(OutputIt out, std::size_t limit) : out_(out), limit_(limit), count_(0)
+    {
+    }
 
-// An output iterator that truncates the output and counts the number of objects
-// written to it.
-template <typename OutputIt,
-          typename Enable = typename std::is_void<
-              typename std::iterator_traits<OutputIt>::value_type>::type>
-class truncating_iterator;
+  public:
+    using iterator_category = std::output_iterator_tag;
+    using difference_type   = void;
+    using pointer           = void;
+    using reference         = void;
+    using _Unchecked_type   = truncating_iterator_base; // Mark iterator as checked.
 
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::false_type>
-    : public truncating_iterator_base<OutputIt> {
-  using traits = std::iterator_traits<OutputIt>;
+    OutputIt    base() const { return out_; }
+    std::size_t count() const { return count_; }
+  };
 
-  mutable typename traits::value_type blackhole_;
+  // An output iterator that truncates the output and counts the number of objects
+  // written to it.
+  template <typename OutputIt,
+            typename Enable =
+                typename std::is_void<typename std::iterator_traits<OutputIt>::value_type>::type>
+  class truncating_iterator;
 
- public:
-  using value_type = typename traits::value_type;
+  template <typename OutputIt>
+  class truncating_iterator<OutputIt, std::false_type> : public truncating_iterator_base<OutputIt>
+  {
+    using traits = std::iterator_traits<OutputIt>;
 
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
+    mutable typename traits::value_type blackhole_;
 
-  truncating_iterator& operator++() {
-    if (this->count_++ < this->limit_) ++this->out_;
-    return *this;
-  }
+  public:
+    using value_type = typename traits::value_type;
 
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
+    truncating_iterator(OutputIt out, std::size_t limit)
+        : truncating_iterator_base<OutputIt>(out, limit)
+    {
+    }
 
-  value_type& operator*() const {
-    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
-  }
-};
+    truncating_iterator &operator++()
+    {
+      if (this->count_++ < this->limit_)
+        ++this->out_;
+      return *this;
+    }
 
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::true_type>
-    : public truncating_iterator_base<OutputIt> {
- public:
-  using value_type = typename OutputIt::container_type::value_type;
+    truncating_iterator operator++(int)
+    {
+      auto it = *this;
+      ++*this;
+      return it;
+    }
 
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
+    value_type &operator*() const { return this->count_ < this->limit_ ? *this->out_ : blackhole_; }
+  };
 
-  truncating_iterator& operator=(value_type val) {
-    if (this->count_++ < this->limit_) this->out_ = val;
-    return *this;
-  }
+  template <typename OutputIt>
+  class truncating_iterator<OutputIt, std::true_type> : public truncating_iterator_base<OutputIt>
+  {
+  public:
+    using value_type = typename OutputIt::container_type::value_type;
 
-  truncating_iterator& operator++() { return *this; }
-  truncating_iterator& operator++(int) { return *this; }
-  truncating_iterator& operator*() { return *this; }
-};
+    truncating_iterator(OutputIt out, std::size_t limit)
+        : truncating_iterator_base<OutputIt>(out, limit)
+    {
+    }
 
-// A range with the specified output iterator and value type.
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
-  OutputIt it_;
+    truncating_iterator &operator=(value_type val)
+    {
+      if (this->count_++ < this->limit_)
+        this->out_ = val;
+      return *this;
+    }
 
- public:
-  using value_type = T;
-  using iterator = OutputIt;
-  struct sentinel {};
+    truncating_iterator &operator++() { return *this; }
+    truncating_iterator &operator++(int) { return *this; }
+    truncating_iterator &operator*() { return *this; }
+  };
 
-  explicit output_range(OutputIt it) : it_(it) {}
-  OutputIt begin() const { return it_; }
-  sentinel end() const { return {}; }  // Sentinel is not used yet.
-};
+  // A range with the specified output iterator and value type.
+  template <typename OutputIt, typename T = typename OutputIt::value_type> class output_range
+  {
+  private:
+    OutputIt it_;
+
+  public:
+    using value_type = T;
+    using iterator   = OutputIt;
+    struct sentinel
+    {
+    };
 
-// A range with an iterator appending to a buffer.
-template <typename T>
-class buffer_range
-    : public output_range<std::back_insert_iterator<buffer<T>>, T> {
- public:
-  using iterator = std::back_insert_iterator<buffer<T>>;
-  using output_range<iterator, T>::output_range;
-  buffer_range(buffer<T>& buf)
-      : output_range<iterator, T>(std::back_inserter(buf)) {}
-};
+    explicit output_range(OutputIt it) : it_(it) {}
+    OutputIt begin() const { return it_; }
+    sentinel end() const { return {}; } // Sentinel is not used yet.
+  };
 
-template <typename Char>
-inline size_t count_code_points(basic_string_view<Char> s) {
-  return s.size();
-}
+  template <typename Char> inline size_t count_code_points(basic_string_view<Char> s)
+  {
+    return s.size();
+  }
 
-// Counts the number of code points in a UTF-8 string.
-inline size_t count_code_points(basic_string_view<char8_t> s) {
-  const char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
+  // Counts the number of code points in a UTF-8 string.
+  inline size_t count_code_points(basic_string_view<char8_t> s)
+  {
+    const char8_t *data            = s.data();
+    size_t         num_code_points = 0;
+    for (size_t i = 0, size = s.size(); i != size; ++i) {
+      if ((data[i] & 0xc0) != 0x80)
+        ++num_code_points;
+    }
+    return num_code_points;
   }
-  return num_code_points;
-}
 
-inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
+  inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
 
-template <typename InputIt, typename OutChar>
-using needs_conversion = bool_constant<
-    std::is_same<typename std::iterator_traits<InputIt>::value_type,
-                 char>::value &&
-    std::is_same<OutChar, char8_t>::value>;
+  template <typename InputIt, typename OutChar>
+  using needs_conversion =
+      bool_constant<std::is_same<typename std::iterator_traits<InputIt>::value_type, char>::value &&
+                    std::is_same<OutChar, char8_t>::value>;
 
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::copy(begin, end, it);
-}
+  template <typename OutChar, typename InputIt, typename OutputIt,
+            FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
+  OutputIt copy_str(InputIt begin, InputIt end, OutputIt it)
+  {
+    return std::copy(begin, end, it);
+  }
 
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::transform(begin, end, it, to_char8_t);
-}
+  template <typename OutChar, typename InputIt, typename OutputIt,
+            FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
+  OutputIt copy_str(InputIt begin, InputIt end, OutputIt it)
+  {
+    return std::transform(begin, end, it, to_char8_t);
+  }
 
 #ifndef FMT_USE_GRISU
-#  define FMT_USE_GRISU 0
+#define FMT_USE_GRISU 1
 #endif
 
-template <typename T> constexpr bool use_grisu() {
-  return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
-         sizeof(T) <= sizeof(double);
-}
+  template <typename T> constexpr bool use_grisu()
+  {
+    return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 && sizeof(T) <= sizeof(double);
+  }
+
+  template <typename T> template <typename U> void buffer<T>::append(const U *begin, const U *end)
+  {
+    std::size_t new_size = size_ + to_unsigned(end - begin);
+    reserve(new_size);
+    std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
+    size_ = new_size;
+  }
+} // namespace internal
 
+// A range with an iterator appending to a buffer.
 template <typename T>
-template <typename U>
-void buffer<T>::append(const U* p_begin, const U* p_end) {
-  std::size_t new_size = size_ + to_unsigned(p_end - p_begin);
-  reserve(new_size);
-  std::uninitialized_copy(p_begin, p_end, make_checked(ptr_, capacity_) + size_);
-  size_ = new_size;
-}
-}  // namespace internal
+class buffer_range
+    : public internal::output_range<std::back_insert_iterator<internal::buffer<T>>, T>
+{
+public:
+  using iterator = std::back_insert_iterator<internal::buffer<T>>;
+  using internal::output_range<iterator, T>::output_range;
+  buffer_range(internal::buffer<T> &buf)
+      : internal::output_range<iterator, T>(std::back_inserter(buf))
+  {
+  }
+};
 
 // A UTF-8 string view.
-class u8string_view : public basic_string_view<char8_t> {
- public:
-  u8string_view(const char* s)
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s)) {}
-  u8string_view(const char* s, size_t count) FMT_NOEXCEPT
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s), count) {
+class u8string_view : public basic_string_view<char8_t>
+{
+public:
+  u8string_view(const char *s) : basic_string_view<char8_t>(reinterpret_cast<const char8_t *>(s)) {}
+  u8string_view(const char *s, size_t count) FMT_NOEXCEPT
+      : basic_string_view<char8_t>(reinterpret_cast<const char8_t *>(s), count)
+  {
   }
 };
 
 #if FMT_USE_USER_DEFINED_LITERALS
 inline namespace literals {
-inline u8string_view operator"" _u(const char* s, std::size_t n) {
-  return {s, n};
-}
-}  // namespace literals
+  inline u8string_view operator"" _u(const char *s, std::size_t n) { return {s, n}; }
+} // namespace literals
 #endif
 
 // The number of characters to store in the basic_memory_buffer object itself
@@ -529,43 +550,47 @@ enum { inline_buffer_size = 500 };
   The output can be converted to an ``std::string`` with ``to_string(out)``.
   \endrst
  */
-template <typename T, std::size_t SIZE = inline_buffer_size,
-          typename Allocator = std::allocator<T>>
-class basic_memory_buffer : private Allocator, public internal::buffer<T> {
- private:
+template <typename T, std::size_t SIZE = inline_buffer_size, typename Allocator = std::allocator<T>>
+class basic_memory_buffer : private Allocator, public internal::buffer<T>
+{
+private:
   T store_[SIZE];
 
   // Deallocate memory allocated by the buffer.
-  void deallocate() {
-    T* p_data = this->data();
-    if (p_data != store_) Allocator::deallocate(p_data, this->capacity());
+  void deallocate()
+  {
+    T *data = this->data();
+    if (data != store_)
+      Allocator::deallocate(data, this->capacity());
   }
 
- protected:
+protected:
   void grow(std::size_t size) FMT_OVERRIDE;
 
- public:
-  using value_type = T;
-  using const_reference = const T&;
+public:
+  using value_type      = T;
+  using const_reference = const T &;
 
-  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
-      : Allocator(alloc) {
+  explicit basic_memory_buffer(const Allocator &alloc = Allocator()) : Allocator(alloc)
+  {
     this->set(store_, SIZE);
   }
   ~basic_memory_buffer() { deallocate(); }
 
- private:
+private:
   // Move data from other to this buffer.
-  void move(basic_memory_buffer& other) {
+  void move(basic_memory_buffer &other)
+  {
     Allocator &this_alloc = *this, &other_alloc = other;
-    this_alloc = std::move(other_alloc);
-    T* data = other.data();
+    this_alloc       = std::move(other_alloc);
+    T *         data = other.data();
     std::size_t size = other.size(), capacity = other.capacity();
     if (data == other.store_) {
       this->set(store_, capacity);
       std::uninitialized_copy(other.store_, other.store_ + size,
                               internal::make_checked(store_, capacity));
-    } else {
+    }
+    else {
       this->set(data, capacity);
       // Set pointer to the inline array so that delete is not called
       // when deallocating.
@@ -574,21 +599,22 @@ class basic_memory_buffer : private Allocator, public internal::buffer<T> {
     this->resize(size);
   }
 
- public:
+public:
   /**
     \rst
     Constructs a :class:`fmt::basic_memory_buffer` object moving the content
     of the other object to it.
     \endrst
    */
-  basic_memory_buffer(basic_memory_buffer&& other) { move(other); }
+  basic_memory_buffer(basic_memory_buffer &&other) { move(other); }
 
   /**
     \rst
     Moves the content of the other ``basic_memory_buffer`` object to this one.
     \endrst
    */
-  basic_memory_buffer& operator=(basic_memory_buffer&& other) {
+  basic_memory_buffer &operator=(basic_memory_buffer &&other)
+  {
     assert(this != &other);
     deallocate();
     move(other);
@@ -600,15 +626,18 @@ class basic_memory_buffer : private Allocator, public internal::buffer<T> {
 };
 
 template <typename T, std::size_t SIZE, typename Allocator>
-void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t p_size) {
+void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size)
+{
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (p_size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
+  if (size > 1000)
+    throw std::runtime_error("fuzz mode - won't grow that much");
 #endif
   std::size_t old_capacity = this->capacity();
   std::size_t new_capacity = old_capacity + old_capacity / 2;
-  if (p_size > new_capacity) new_capacity = p_size;
-  T* old_data = this->data();
-  T* new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
+  if (size > new_capacity)
+    new_capacity = size;
+  T *old_data = this->data();
+  T *new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
   // The following code doesn't throw, so the raw pointer above doesn't leak.
   std::uninitialized_copy(old_data, old_data + this->size(),
                           internal::make_checked(new_data, new_capacity));
@@ -616,2004 +645,2151 @@ void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t p_size) {
   // deallocate must not throw according to the standard, but even if it does,
   // the buffer already uses the new storage and will deallocate it in
   // destructor.
-  if (old_data != store_) Allocator::deallocate(old_data, old_capacity);
+  if (old_data != store_)
+    Allocator::deallocate(old_data, old_capacity);
 }
 
-using memory_buffer = basic_memory_buffer<char>;
+using memory_buffer  = basic_memory_buffer<char>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;
 
 /** A formatting error such as invalid format string. */
-class FMT_API format_error : public std::runtime_error {
- public:
-  explicit format_error(const char* message) : std::runtime_error(message) {}
-  explicit format_error(const std::string& message)
-      : std::runtime_error(message) {}
+class FMT_API format_error : public std::runtime_error
+{
+public:
+  explicit format_error(const char *message) : std::runtime_error(message) {}
+  explicit format_error(const std::string &message) : std::runtime_error(message) {}
+  format_error(const format_error &) = default;
+  format_error &operator=(const format_error &) = default;
+  format_error(format_error &&)                 = default;
+  format_error &operator=(format_error &&) = default;
   ~format_error() FMT_NOEXCEPT;
 };
 
 namespace internal {
 
-// Returns true if value is negative, false otherwise.
-// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
-template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T value) {
-  return value < 0;
-}
-template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T) {
-  return false;
-}
-
-// Smallest of uint32_t and uint64_t that is large enough to represent all
-// values of T.
-template <typename T>
-using uint32_or_64_t =
-    conditional_t<std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>;
-
-// Static data is placed in this class template for the header-only config.
-template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
-  static const uint64_t powers_of_10_64[];
-  static const uint32_t zero_or_powers_of_10_32[];
-  static const uint64_t zero_or_powers_of_10_64[];
-  static const uint64_t pow10_significands[];
-  static const int16_t pow10_exponents[];
-  static const char digits[];
-  static const char hex_digits[];
-  static const char foreground_color[];
-  static const char background_color[];
-  static const char reset_color[5];
-  static const wchar_t wreset_color[5];
-};
+  // Returns true if value is negative, false otherwise.
+  // Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
+  template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
+  FMT_CONSTEXPR bool is_negative(T value)
+  {
+    return value < 0;
+  }
+  template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
+  FMT_CONSTEXPR bool is_negative(T)
+  {
+    return false;
+  }
+
+  // Smallest of uint32_t, uint64_t, uint128_t that is large enough to
+  // represent all values of T.
+  template <typename T>
+  using uint32_or_64_or_128_t =
+      conditional_t<std::numeric_limits<T>::digits <= 32, uint32_t,
+                    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
+
+  // Static data is placed in this class template for the header-only config.
+  template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data
+  {
+    static const uint64_t powers_of_10_64[];
+    static const uint32_t zero_or_powers_of_10_32[];
+    static const uint64_t zero_or_powers_of_10_64[];
+    static const uint64_t pow10_significands[];
+    static const int16_t  pow10_exponents[];
+    static const char     digits[];
+    static const char     hex_digits[];
+    static const char     foreground_color[];
+    static const char     background_color[];
+    static const char     reset_color[5];
+    static const wchar_t  wreset_color[5];
+    static const char     signs[];
+  };
 
-FMT_EXTERN template struct basic_data<void>;
+  FMT_EXTERN template struct basic_data<void>;
 
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
+  // This is a struct rather than an alias to avoid shadowing warnings in gcc.
+  struct data : basic_data<>
+  {
+  };
 
 #ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline int count_digits(uint64_t n) {
-  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
-}
+  // Returns the number of decimal digits in n. Leading zeros are not counted
+  // except for n == 0 in which case count_digits returns 1.
+  inline int count_digits(uint64_t n)
+  {
+    // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+    // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
+    int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+    return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
+  }
 #else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline int count_digits(uint64_t n) {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000u;
-    count += 4;
+  // Fallback version of count_digits used when __builtin_clz is not available.
+  inline int count_digits(uint64_t n)
+  {
+    int count = 1;
+    for (;;) {
+      // Integer division is slow so do it for a group of four digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      if (n < 10)
+        return count;
+      if (n < 100)
+        return count + 1;
+      if (n < 1000)
+        return count + 2;
+      if (n < 10000)
+        return count + 3;
+      n /= 10000u;
+      count += 4;
+    }
   }
-}
 #endif
 
-// Counts the number of digits in n. BITS = log2(radix).
-template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
-  int num_digits = 0;
-  do {
-    ++num_digits;
-  } while ((n >>= BITS) != 0);
-  return num_digits;
-}
+#if FMT_USE_INT128
+  inline int count_digits(uint128_t n)
+  {
+    int count = 1;
+    for (;;) {
+      // Integer division is slow so do it for a group of four digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      if (n < 10)
+        return count;
+      if (n < 100)
+        return count + 1;
+      if (n < 1000)
+        return count + 2;
+      if (n < 10000)
+        return count + 3;
+      n /= 10000u;
+      count += 4;
+    }
+  }
+#endif
 
-template <> int count_digits<4>(internal::fallback_uintptr n);
+  // Counts the number of digits in n. BITS = log2(radix).
+  template <unsigned BITS, typename UInt> inline int count_digits(UInt n)
+  {
+    int num_digits = 0;
+    do {
+      ++num_digits;
+    } while ((n >>= BITS) != 0);
+    return num_digits;
+  }
+
+  template <> int count_digits<4>(internal::fallback_uintptr n);
 
 #if FMT_HAS_CPP_ATTRIBUTE(always_inline)
-#  define FMT_ALWAYS_INLINE __attribute__((always_inline))
+#define FMT_ALWAYS_INLINE __attribute__((always_inline))
 #else
-#  define FMT_ALWAYS_INLINE
+#define FMT_ALWAYS_INLINE
 #endif
 
-template <typename Handler>
-inline char* lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
-
-// Computes g = floor(log10(n)) and calls h.on<g>(n);
-template <typename Handler> inline char* lg(uint32_t n, Handler h) {
-  return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
-                 : n < 1000000
-                       ? n < 10000 ? n < 1000 ? h.template on<2>(n)
-                                              : h.template on<3>(n)
-                                   : n < 100000 ? h.template on<4>(n)
-                                                : h.template on<5>(n)
-                       : n < 100000000 ? n < 10000000 ? h.template on<6>(n)
-                                                      : h.template on<7>(n)
-                                       : n < 1000000000 ? h.template on<8>(n)
-                                                        : h.template on<9>(n);
-}
+  template <typename Handler> inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
+
+  // Computes g = floor(log10(n)) and calls h.on<g>(n);
+  template <typename Handler> inline char *lg(uint32_t n, Handler h)
+  {
+    return n < 100
+               ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
+               : n < 1000000
+                     ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n)
+                                 : n < 100000 ? h.template on<4>(n) : h.template on<5>(n)
+                     : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n)
+                                     : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n);
+  }
+
+  // An lg handler that formats a decimal number.
+  // Usage: lg(n, decimal_formatter(buffer));
+  class decimal_formatter
+  {
+  private:
+    char *buffer_;
+
+    void write_pair(unsigned N, uint32_t index)
+    {
+      std::memcpy(buffer_ + N, data::digits + index * 2, 2);
+    }
+
+  public:
+    explicit decimal_formatter(char *buf) : buffer_(buf) {}
 
-// An lg handler that formats a decimal number.
-// Usage: lg(n, decimal_formatter(buffer));
-class decimal_formatter {
- private:
-  char* buffer_;
-
-  void write_pair(unsigned N, uint32_t index) {
-    std::memcpy(buffer_ + N, data::digits + index * 2, 2);
-  }
-
- public:
-  explicit decimal_formatter(char* buf) : buffer_(buf) {}
-
-  template <unsigned N> char* on(uint32_t u) {
-    if (N == 0) {
-      *buffer_ = static_cast<char>(u) + '0';
-    } else if (N == 1) {
-      write_pair(0, u);
-    } else {
-      // The idea of using 4.32 fixed-point numbers is based on
-      // https://github.com/jeaiii/itoa
-      unsigned n = N - 1;
-      unsigned a = n / 5 * n * 53 / 16;
-      uint64_t t =
-          ((1ULL << (32 + a)) / data::zero_or_powers_of_10_32[n] + 1 - n / 9);
-      t = ((t * u) >> a) + n / 5 * 4;
-      write_pair(0, t >> 32);
-      for (unsigned i = 2; i < N; i += 2) {
-        t = 100ULL * static_cast<uint32_t>(t);
-        write_pair(i, t >> 32);
+    template <unsigned N> char *on(uint32_t u)
+    {
+      if (N == 0) {
+        *buffer_ = static_cast<char>(u) + '0';
+      }
+      else if (N == 1) {
+        write_pair(0, u);
       }
-      if (N % 2 == 0) {
-        buffer_[N] =
-            static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
+      else {
+        // The idea of using 4.32 fixed-point numbers is based on
+        // https://github.com/jeaiii/itoa
+        unsigned n = N - 1;
+        unsigned a = n / 5 * n * 53 / 16;
+        uint64_t t = ((1ULL << (32 + a)) / data::zero_or_powers_of_10_32[n] + 1 - n / 9);
+        t          = ((t * u) >> a) + n / 5 * 4;
+        write_pair(0, t >> 32);
+        for (unsigned i = 2; i < N; i += 2) {
+          t = 100ULL * static_cast<uint32_t>(t);
+          write_pair(i, t >> 32);
+        }
+        if (N % 2 == 0) {
+          buffer_[N] = static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
+        }
       }
+      return buffer_ += N + 1;
     }
-    return buffer_ += N + 1;
-  }
-};
+  };
 
 #ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline int count_digits(uint32_t n) {
-  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
-}
+  // Optional version of count_digits for better performance on 32-bit platforms.
+  inline int count_digits(uint32_t n)
+  {
+    int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+    return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
+  }
 #endif
 
-template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
-template <typename Char> inline Char thousands_sep(locale_ref loc) {
-  return Char(thousands_sep_impl<char>(loc));
-}
-template <> inline wchar_t thousands_sep(locale_ref loc) {
-  return thousands_sep_impl<wchar_t>(loc);
-}
+  template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
+  template <typename Char> inline Char  thousands_sep(locale_ref loc)
+  {
+    return Char(thousands_sep_impl<char>(loc));
+  }
+  template <> inline wchar_t thousands_sep(locale_ref loc)
+  {
+    return thousands_sep_impl<wchar_t>(loc);
+  }
 
-template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
-template <typename Char> inline Char decimal_point(locale_ref loc) {
-  return Char(decimal_point_impl<char>(loc));
-}
-template <> inline wchar_t decimal_point(locale_ref loc) {
-  return decimal_point_impl<wchar_t>(loc);
-}
+  template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
+  template <typename Char> inline Char  decimal_point(locale_ref loc)
+  {
+    return Char(decimal_point_impl<char>(loc));
+  }
+  template <> inline wchar_t decimal_point(locale_ref loc)
+  {
+    return decimal_point_impl<wchar_t>(loc);
+  }
 
-// Formats a decimal unsigned integer value writing into buffer.
-// add_thousands_sep is called after writing each char to add a thousands
-// separator if necessary.
-template <typename UInt, typename Char, typename F>
-inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
-                            F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  buffer += num_digits;
-  Char* end = buffer;
-  while (value >= 100) {
-    // Integer division is slow so do it for a group of two digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    unsigned index = static_cast<unsigned>((value % 100) * 2);
-    value /= 100;
-    *--buffer = static_cast<Char>(data::digits[index + 1]);
+  // Formats a decimal unsigned integer value writing into buffer.
+  // add_thousands_sep is called after writing each char to add a thousands
+  // separator if necessary.
+  template <typename UInt, typename Char, typename F>
+  inline Char *format_decimal(Char *buffer, UInt value, int num_digits, F add_thousands_sep)
+  {
+    FMT_ASSERT(num_digits >= 0, "invalid digit count");
+    buffer += num_digits;
+    Char *end = buffer;
+    while (value >= 100) {
+      // Integer division is slow so do it for a group of two digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      unsigned index = static_cast<unsigned>((value % 100) * 2);
+      value /= 100;
+      *--buffer = static_cast<Char>(data::digits[index + 1]);
+      add_thousands_sep(buffer);
+      *--buffer = static_cast<Char>(data::digits[index]);
+      add_thousands_sep(buffer);
+    }
+    if (value < 10) {
+      *--buffer = static_cast<Char>('0' + value);
+      return end;
+    }
+    unsigned index = static_cast<unsigned>(value * 2);
+    *--buffer      = static_cast<Char>(data::digits[index + 1]);
     add_thousands_sep(buffer);
     *--buffer = static_cast<Char>(data::digits[index]);
-    add_thousands_sep(buffer);
-  }
-  if (value < 10) {
-    *--buffer = static_cast<Char>('0' + value);
     return end;
   }
-  unsigned index = static_cast<unsigned>(value * 2);
-  *--buffer = static_cast<Char>(data::digits[index + 1]);
-  add_thousands_sep(buffer);
-  *--buffer = static_cast<Char>(data::digits[index]);
-  return end;
-}
-
-template <typename Char, typename UInt, typename Iterator, typename F>
-inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
-                               F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  // Buffer should be large enough to hold all digits (<= digits10 + 1).
-  enum { max_size = std::numeric_limits<UInt>::digits10 + 1 };
-  Char buffer[max_size + max_size / 3];
-  auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
-  return internal::copy_str<Char>(buffer, end, out);
-}
-
-template <typename Char, typename It, typename UInt>
-inline It format_decimal(It out, UInt value, int num_digits) {
-  return format_decimal<Char>(out, value, num_digits, [](Char*) {});
-}
 
-template <unsigned BASE_BITS, typename Char, typename UInt>
-inline Char* format_uint(Char* buffer, UInt value, int num_digits,
-                         bool upper = false) {
-  buffer += num_digits;
-  Char* end = buffer;
-  do {
-    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
-    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
-                                                : digits[digit]);
-  } while ((value >>= BASE_BITS) != 0);
-  return end;
-}
+  template <typename Int> constexpr int digits10() noexcept
+  {
+    return std::numeric_limits<Int>::digits10;
+  }
+  template <> constexpr int digits10<int128_t>() noexcept { return 38; }
+  template <> constexpr int digits10<uint128_t>() noexcept { return 38; }
+
+  template <typename Char, typename UInt, typename Iterator, typename F>
+  inline Iterator format_decimal(Iterator out, UInt value, int num_digits, F add_thousands_sep)
+  {
+    FMT_ASSERT(num_digits >= 0, "invalid digit count");
+    // Buffer should be large enough to hold all digits (<= digits10 + 1).
+    enum { max_size = digits10<UInt>() + 1 };
+    Char buffer[max_size + max_size / 3];
+    auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
+    return internal::copy_str<Char>(buffer, end, out);
+  }
+
+  template <typename Char, typename It, typename UInt>
+  inline It format_decimal(It out, UInt value, int num_digits)
+  {
+    return format_decimal<Char>(out, value, num_digits, [](Char *) {});
+  }
+
+  template <unsigned BASE_BITS, typename Char, typename UInt>
+  inline Char *format_uint(Char *buffer, UInt value, int num_digits, bool upper = false)
+  {
+    buffer += num_digits;
+    Char *end = buffer;
+    do {
+      const char *digits = upper ? "0123456789ABCDEF" : data::hex_digits;
+      unsigned    digit  = (value & ((1 << BASE_BITS) - 1));
+      *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
+    } while ((value >>= BASE_BITS) != 0);
+    return end;
+  }
 
-template <unsigned BASE_BITS, typename Char>
-Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,
-                  bool = false) {
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  int start = (num_digits + char_digits - 1) / char_digits - 1;
-  if (int start_digits = num_digits % char_digits) {
-    unsigned value = n.value[start--];
-    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
-  }
-  for (; start >= 0; --start) {
-    unsigned value = n.value[start];
-    buffer += char_digits;
-    auto p = buffer;
-    for (int i = 0; i < char_digits; ++i) {
-      unsigned digit = (value & ((1 << BASE_BITS) - 1));
-      *--p = static_cast<Char>(data::hex_digits[digit]);
-      value >>= BASE_BITS;
-    }
-  }
-  return buffer;
-}
+  template <unsigned BASE_BITS, typename Char>
+  Char *format_uint(Char *buffer, internal::fallback_uintptr n, int num_digits, bool = false)
+  {
+    auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+    int  start       = (num_digits + char_digits - 1) / char_digits - 1;
+    if (int start_digits = num_digits % char_digits) {
+      unsigned value = n.value[start--];
+      buffer         = format_uint<BASE_BITS>(buffer, value, start_digits);
+    }
+    for (; start >= 0; --start) {
+      unsigned value = n.value[start];
+      buffer += char_digits;
+      auto p = buffer;
+      for (int i = 0; i < char_digits; ++i) {
+        unsigned digit = (value & ((1 << BASE_BITS) - 1));
+        *--p           = static_cast<Char>(data::hex_digits[digit]);
+        value >>= BASE_BITS;
+      }
+    }
+    return buffer;
+  }
 
-template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
-inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
-  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 1];
-  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return internal::copy_str<Char>(buffer, buffer + num_digits, out);
-}
+  template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
+  inline It format_uint(It out, UInt value, int num_digits, bool upper = false)
+  {
+    // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
+    char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 1];
+    format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+    return internal::copy_str<Char>(buffer, buffer + num_digits, out);
+  }
 
 #ifndef _WIN32
-#  define FMT_USE_WINDOWS_H 0
+#define FMT_USE_WINDOWS_H 0
 #elif !defined(FMT_USE_WINDOWS_H)
-#  define FMT_USE_WINDOWS_H 1
+#define FMT_USE_WINDOWS_H 1
 #endif
 
 // Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
 // All the functionality that relies on it will be disabled too.
 #if FMT_USE_WINDOWS_H
-// A converter from UTF-8 to UTF-16.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class utf8_to_utf16 {
- private:
-  wmemory_buffer buffer_;
-
- public:
-  FMT_API explicit utf8_to_utf16(string_view s);
-  operator wstring_view() const { return wstring_view(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const wchar_t* c_str() const { return &buffer_[0]; }
-  std::wstring str() const { return std::wstring(&buffer_[0], size()); }
-};
+  // A converter from UTF-8 to UTF-16.
+  // It is only provided for Windows since other systems support UTF-8 natively.
+  class utf8_to_utf16
+  {
+  private:
+    wmemory_buffer buffer_;
+
+  public:
+    FMT_API explicit utf8_to_utf16(string_view s);
+                   operator wstring_view() const { return wstring_view(&buffer_[0], size()); }
+    size_t         size() const { return buffer_.size() - 1; }
+    const wchar_t *c_str() const { return &buffer_[0]; }
+    std::wstring   str() const { return std::wstring(&buffer_[0], size()); }
+  };
 
-// A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class utf16_to_utf8 {
- private:
-  memory_buffer buffer_;
-
- public:
-  utf16_to_utf8() {}
-  FMT_API explicit utf16_to_utf8(wstring_view s);
-  operator string_view() const { return string_view(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const char* c_str() const { return &buffer_[0]; }
-  std::string str() const { return std::string(&buffer_[0], size()); }
-
-  // Performs conversion returning a system error code instead of
-  // throwing exception on conversion error. This method may still throw
-  // in case of memory allocation error.
-  FMT_API int convert(wstring_view s);
-};
+  // A converter from UTF-16 to UTF-8.
+  // It is only provided for Windows since other systems support UTF-8 natively.
+  class utf16_to_utf8
+  {
+  private:
+    memory_buffer buffer_;
+
+  public:
+    utf16_to_utf8() {}
+    FMT_API explicit utf16_to_utf8(wstring_view s);
+                operator string_view() const { return string_view(&buffer_[0], size()); }
+    size_t      size() const { return buffer_.size() - 1; }
+    const char *c_str() const { return &buffer_[0]; }
+    std::string str() const { return std::string(&buffer_[0], size()); }
+
+    // Performs conversion returning a system error code instead of
+    // throwing exception on conversion error. This method may still throw
+    // in case of memory allocation error.
+    FMT_API int convert(wstring_view s);
+  };
 
-FMT_API void format_windows_error(fmt::internal::buffer<char>& out,
-                                  int error_code,
-                                  fmt::string_view message) FMT_NOEXCEPT;
+  FMT_API void format_windows_error(fmt::internal::buffer<char> &out, int error_code,
+                                    fmt::string_view message) FMT_NOEXCEPT;
 #endif
 
-template <typename T = void> struct null {};
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  Char data_[6];
-
- public:
-  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
-  FMT_CONSTEXPR const Char& operator[](size_t index) const {
-    return data_[index];
-  }
+  template <typename T = void> struct null
+  {
+  };
 
-  static FMT_CONSTEXPR fill_t<Char> make() {
-    auto fill = fill_t<Char>();
-    fill[0] = Char(' ');
-    return fill;
-  }
-};
-}  // namespace internal
+  // Workaround an array initialization issue in gcc 4.8.
+  template <typename Char> struct fill_t
+  {
+  private:
+    Char data_[6];
+
+  public:
+    FMT_CONSTEXPR Char &operator[](size_t index) { return data_[index]; }
+    FMT_CONSTEXPR const Char &operator[](size_t index) const { return data_[index]; }
+
+    static FMT_CONSTEXPR fill_t<Char> make()
+    {
+      auto fill = fill_t<Char>();
+      fill[0]   = Char(' ');
+      return fill;
+    }
+  };
+} // namespace internal
 
 // We cannot use enum classes as bit fields because of a gcc bug
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
 namespace align {
-enum type { none, left, right, center, numeric };
+  enum type { none, left, right, center, numeric };
 }
 using align_t = align::type;
 
 namespace sign {
-enum type { none, minus, plus, space };
+  enum type { none, minus, plus, space };
 }
 using sign_t = sign::type;
 
 // Format specifiers for built-in and string types.
-template <typename Char> struct basic_format_specs {
-  int width;
-  int precision;
-  char type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
+template <typename Char> struct basic_format_specs
+{
+  int                    width;
+  int                    precision;
+  char                   type;
+  align_t                align : 4;
+  sign_t                 sign : 3;
+  bool                   alt : 1; // Alternate form ('#').
   internal::fill_t<Char> fill;
 
   constexpr basic_format_specs()
-      : width(0),
-        precision(-1),
-        type(0),
-        align(align::none),
-        sign(sign::none),
-        alt(false),
-        fill(internal::fill_t<Char>::make()) {}
+      : width(0), precision(-1), type(0), align(align::none), sign(sign::none), alt(false),
+        fill(internal::fill_t<Char>::make())
+  {
+  }
 };
 
 using format_specs = basic_format_specs<char>;
 
 namespace internal {
 
-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Char, typename It> It write_exponent(int exp, It it) {
-  FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
-  if (exp < 0) {
-    *it++ = static_cast<Char>('-');
-    exp = -exp;
-  } else {
-    *it++ = static_cast<Char>('+');
-  }
-  if (exp >= 100) {
-    *it++ = static_cast<Char>(static_cast<char>('0' + exp / 100));
-    exp %= 100;
-  }
-  const char* d = data::digits + exp * 2;
-  *it++ = static_cast<Char>(d[0]);
-  *it++ = static_cast<Char>(d[1]);
-  return it;
-}
+  struct gen_digits_params
+  {
+    int    num_digits;
+    sign_t sign : 3;
+    bool   fixed;
+    bool   upper;
+    bool   trailing_zeros;
+  };
 
-struct gen_digits_params {
-  int num_digits;
-  bool fixed;
-  bool upper;
-  bool trailing_zeros;
-};
+  // Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
+  template <typename Char, typename It> It write_exponent(int exp, It it)
+  {
+    FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
+    if (exp < 0) {
+      *it++ = static_cast<Char>('-');
+      exp   = -exp;
+    }
+    else {
+      *it++ = static_cast<Char>('+');
+    }
+    if (exp >= 100) {
+      *it++ = static_cast<Char>(static_cast<char>('0' + exp / 100));
+      exp %= 100;
+    }
+    const char *d = data::digits + exp * 2;
+    *it++         = static_cast<Char>(d[0]);
+    *it++         = static_cast<Char>(d[1]);
+    return it;
+  }
 
-// The number is given as v = digits * pow(10, exp).
-template <typename Char, typename It>
-It grisu_prettify(const char* digits, int size, int exp, It it,
-                  gen_digits_params params, Char decimal_point) {
-  // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
-  int full_exp = size + exp;
-  if (!params.fixed) {
-    // Insert a decimal point after the first digit and add an exponent.
-    *it++ = static_cast<Char>(*digits);
-    if (size > 1) *it++ = decimal_point;
-    exp += size - 1;
-    it = copy_str<Char>(digits + 1, digits + size, it);
-    if (size < params.num_digits)
-      it = std::fill_n(it, params.num_digits - size, static_cast<Char>('0'));
-    *it++ = static_cast<Char>(params.upper ? 'E' : 'e');
-    return write_exponent<Char>(exp, it);
-  }
-  if (size <= full_exp) {
-    // 1234e7 -> 12340000000[.0+]
-    it = copy_str<Char>(digits, digits + size, it);
-    it = std::fill_n(it, full_exp - size, static_cast<Char>('0'));
-    int num_zeros = (std::max)(params.num_digits - full_exp, 1);
-    if (params.trailing_zeros) {
-      *it++ = decimal_point;
+  template <typename Char> class grisu_writer
+  {
+  private:
+    // The number is given as v = digits_ * pow(10, exp_).
+    const char *      digits_;
+    int               num_digits_;
+    int               exp_;
+    size_t            size_;
+    gen_digits_params params_;
+    Char              decimal_point_;
+
+    template <typename It> It grisu_prettify(It it) const
+    {
+      // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
+      int full_exp = num_digits_ + exp_;
+      if (!params_.fixed) {
+        // Insert a decimal point after the first digit and add an exponent.
+        *it++ = static_cast<Char>(*digits_);
+        if (num_digits_ > 1)
+          *it++ = decimal_point_;
+        it    = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
+        *it++ = static_cast<Char>(params_.upper ? 'E' : 'e');
+        return write_exponent<Char>(full_exp - 1, it);
+      }
+      if (num_digits_ <= full_exp) {
+        // 1234e7 -> 12340000000[.0+]
+        it            = copy_str<Char>(digits_, digits_ + num_digits_, it);
+        it            = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
+        int num_zeros = (std::max)(params_.num_digits - full_exp, 1);
+        if (params_.trailing_zeros) {
+          *it++ = decimal_point_;
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-      if (num_zeros > 1000)
-        throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
+          if (num_zeros > 1000)
+            throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
 #endif
-      it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-    }
-  } else if (full_exp > 0) {
-    // 1234e-2 -> 12.34[0+]
-    it = copy_str<Char>(digits, digits + full_exp, it);
-    if (!params.trailing_zeros) {
-      // Remove trailing zeros.
-      while (size > full_exp && digits[size - 1] == '0') --size;
-      if (size != full_exp) *it++ = decimal_point;
-      return copy_str<Char>(digits + full_exp, digits + size, it);
-    }
-    *it++ = decimal_point;
-    it = copy_str<Char>(digits + full_exp, digits + size, it);
-    if (params.num_digits > size) {
-      // Add trailing zeros.
-      int num_zeros = params.num_digits - size;
-      it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-    }
-  } else {
-    // 1234e-6 -> 0.001234
-    *it++ = static_cast<Char>('0');
-    int num_zeros = -full_exp;
-    if (params.num_digits >= 0 && params.num_digits < num_zeros)
-      num_zeros = params.num_digits;
-    if (!params.trailing_zeros)
-      while (size > 0 && digits[size - 1] == '0') --size;
-    if (num_zeros != 0 || size != 0) {
-      *it++ = decimal_point;
-      it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      it = copy_str<Char>(digits, digits + size, it);
-    }
-  }
-  return it;
-}
-
-namespace grisu_options {
-enum { fixed = 1, grisu3 = 2 };
-}
-
-// Formats value using the Grisu algorithm:
-// https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf
-template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
-FMT_API bool grisu_format(Double, buffer<char>&, int, unsigned, int&);
-template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
-inline bool grisu_format(Double, buffer<char>&, int, unsigned, int&) {
-  return false;
-}
+          it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+        }
+      }
+      else if (full_exp > 0) {
+        // 1234e-2 -> 12.34[0+]
+        it = copy_str<Char>(digits_, digits_ + full_exp, it);
+        if (!params_.trailing_zeros) {
+          // Remove trailing zeros.
+          int num_digits = num_digits_;
+          while (num_digits > full_exp && digits_[num_digits - 1] == '0')
+            --num_digits;
+          if (num_digits != full_exp)
+            *it++ = decimal_point_;
+          return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
+        }
+        *it++ = decimal_point_;
+        it    = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
+        if (params_.num_digits > num_digits_) {
+          // Add trailing zeros.
+          int num_zeros = params_.num_digits - num_digits_;
+          it            = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+        }
+      }
+      else {
+        // 1234e-6 -> 0.001234
+        *it++         = static_cast<Char>('0');
+        int num_zeros = -full_exp;
+        if (params_.num_digits >= 0 && params_.num_digits < num_zeros)
+          num_zeros = params_.num_digits;
+        int num_digits = num_digits_;
+        if (!params_.trailing_zeros)
+          while (num_digits > 0 && digits_[num_digits - 1] == '0')
+            --num_digits;
+        if (num_zeros != 0 || num_digits != 0) {
+          *it++ = decimal_point_;
+          it    = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+          it    = copy_str<Char>(digits_, digits_ + num_digits, it);
+        }
+      }
+      return it;
+    }
 
-struct sprintf_specs {
-  int precision;
-  char type;
-  bool alt : 1;
+  public:
+    grisu_writer(const char *digits, int num_digits, int exp, gen_digits_params params,
+                 Char decimal_point)
+        : digits_(digits), num_digits_(num_digits), exp_(exp), params_(params),
+          decimal_point_(decimal_point)
+    {
+      int full_exp  = num_digits + exp - 1;
+      int precision = params.num_digits > 0 ? params.num_digits : 16;
+      params_.fixed |= full_exp >= -4 && full_exp < precision;
+      size_ = grisu_prettify(counting_iterator()).count();
+      size_ += params_.sign ? 1 : 0;
+    }
 
-  template <typename Char>
-  constexpr sprintf_specs(basic_format_specs<Char> specs)
-      : precision(specs.precision), type(specs.type), alt(specs.alt) {}
+    size_t size() const { return size_; }
+    size_t width() const { return size(); }
 
-  constexpr bool has_precision() const { return precision >= 0; }
-};
+    template <typename It> void operator()(It &&it)
+    {
+      if (params_.sign)
+        *it++ = static_cast<Char>(data::signs[params_.sign]);
+      it = grisu_prettify(it);
+    }
+  };
 
-template <typename Double>
-char* sprintf_format(Double, internal::buffer<char>&, sprintf_specs);
-
-template <typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
-  case 0:
-  case 'd':
-    handler.on_dec();
-    break;
-  case 'x':
-  case 'X':
-    handler.on_hex();
-    break;
-  case 'b':
-  case 'B':
-    handler.on_bin();
-    break;
-  case 'o':
-    handler.on_oct();
-    break;
-  case 'n':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error();
+  namespace grisu_options {
+    enum { fixed = 1, grisu2 = 2, binary32 = 4 };
   }
-}
 
-template <typename Handler>
-FMT_CONSTEXPR void handle_float_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
-  case 0:
-  case 'g':
-  case 'G':
-    handler.on_general();
-    break;
-  case 'e':
-  case 'E':
-    handler.on_exp();
-    break;
-  case 'f':
-  case 'F':
-    handler.on_fixed();
-    break;
-  case '%':
-    handler.on_percent();
-    break;
-  case 'a':
-  case 'A':
-    handler.on_hex();
-    break;
-  case 'n':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error();
-    break;
+  // Formats value using the Grisu algorithm:
+  // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf
+  template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
+  FMT_API bool grisu_format(Double, buffer<char> &, int, unsigned, int &);
+  template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
+  inline bool grisu_format(Double, buffer<char> &, int, unsigned, int &)
+  {
+    return false;
   }
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
-                                     Handler&& handler) {
-  if (!specs) return handler.on_char();
-  if (specs->type && specs->type != 'c') return handler.on_int();
-  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
-    handler.on_error("invalid format specifier for char");
-  handler.on_char();
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
-  if (spec == 0 || spec == 's')
-    handler.on_string();
-  else if (spec == 'p')
-    handler.on_pointer();
-  else
-    handler.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
-}
 
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
-}
+  struct sprintf_specs
+  {
+    int  precision;
+    char type;
+    bool alt : 1;
 
-template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
+    template <typename Char>
+    constexpr sprintf_specs(basic_format_specs<Char> specs)
+        : precision(specs.precision), type(specs.type), alt(specs.alt)
+    {
+    }
 
-  FMT_CONSTEXPR void on_dec() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_bin() {}
-  FMT_CONSTEXPR void on_oct() {}
-  FMT_CONSTEXPR void on_num() {}
+    constexpr bool has_precision() const { return precision >= 0; }
+  };
 
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
+  template <typename Double> char *sprintf_format(Double, internal::buffer<char> &, sprintf_specs);
+
+  template <>
+  inline char *sprintf_format<float>(float value, internal::buffer<char> &buf, sprintf_specs specs)
+  {
+    // printf does not have a float format specifier, it only supports double.
+    return sprintf_format<double>(value, buf, specs);
+  }
+
+  template <typename Handler> FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler &&handler)
+  {
+    switch (spec) {
+    case 0:
+    case 'd': handler.on_dec(); break;
+    case 'x':
+    case 'X': handler.on_hex(); break;
+    case 'b':
+    case 'B': handler.on_bin(); break;
+    case 'o': handler.on_oct(); break;
+    case 'n': handler.on_num(); break;
+    default: handler.on_error();
+    }
   }
-};
-
-template <typename ErrorHandler>
-class float_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_general() {}
-  FMT_CONSTEXPR void on_exp() {}
-  FMT_CONSTEXPR void on_fixed() {}
-  FMT_CONSTEXPR void on_percent() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_num() {}
 
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
+  template <typename Handler>
+  FMT_CONSTEXPR void handle_float_type_spec(char spec, Handler &&handler)
+  {
+    switch (spec) {
+    case 0:
+    case 'g':
+    case 'G': handler.on_general(); break;
+    case 'e':
+    case 'E': handler.on_exp(); break;
+    case 'f':
+    case 'F': handler.on_fixed(); break;
+    case '%': handler.on_percent(); break;
+    case 'a':
+    case 'A': handler.on_hex(); break;
+    case 'n': handler.on_num(); break;
+    default: handler.on_error(); break;
+    }
   }
-};
 
-template <typename ErrorHandler>
-class char_specs_checker : public ErrorHandler {
- private:
-  char type_;
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char> *specs, Handler &&handler)
+  {
+    if (!specs)
+      return handler.on_char();
+    if (specs->type && specs->type != 'c')
+      return handler.on_int();
+    if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
+      handler.on_error("invalid format specifier for char");
+    handler.on_char();
+  }
+
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler)
+  {
+    if (spec == 0 || spec == 's')
+      handler.on_string();
+    else if (spec == 'p')
+      handler.on_pointer();
+    else
+      handler.on_error("invalid type specifier");
+  }
 
- public:
-  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
-      : ErrorHandler(eh), type_(type) {}
+  template <typename Char, typename ErrorHandler>
+  FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh)
+  {
+    if (spec != 0 && spec != 's')
+      eh.on_error("invalid type specifier");
+  }
 
-  FMT_CONSTEXPR void on_int() {
-    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
+  template <typename Char, typename ErrorHandler>
+  FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh)
+  {
+    if (spec != 0 && spec != 'p')
+      eh.on_error("invalid type specifier");
   }
-  FMT_CONSTEXPR void on_char() {}
-};
 
-template <typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
+  template <typename ErrorHandler> class int_type_checker : private ErrorHandler
+  {
+  public:
+    FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
-  FMT_CONSTEXPR void on_string() {}
-  FMT_CONSTEXPR void on_pointer() {}
-};
+    FMT_CONSTEXPR void on_dec() {}
+    FMT_CONSTEXPR void on_hex() {}
+    FMT_CONSTEXPR void on_bin() {}
+    FMT_CONSTEXPR void on_oct() {}
+    FMT_CONSTEXPR void on_num() {}
 
-template <typename Context>
-void arg_map<Context>::init(const basic_format_args<Context>& args) {
-  if (map_) return;
-  map_ = new entry[internal::to_unsigned(args.max_size())];
-  if (args.is_packed()) {
-    for (int i = 0;; ++i) {
-      internal::type arg_type = args.type(i);
-      if (arg_type == internal::none_type) return;
-      if (arg_type == internal::named_arg_type) push_back(args.values_[i]);
-    }
-  }
-  for (int i = 0, n = args.max_size(); i < n; ++i) {
-    auto type = args.args_[i].type_;
-    if (type == internal::named_arg_type) push_back(args.args_[i].value_);
-  }
-}
+    FMT_CONSTEXPR void on_error() { ErrorHandler::on_error("invalid type specifier"); }
+  };
 
-// This template provides operations for formatting and writing data into a
-// character range.
-template <typename Range> class basic_writer {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
+  template <typename ErrorHandler> class float_type_checker : private ErrorHandler
+  {
+  public:
+    FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
- private:
-  iterator out_;  // Output iterator.
-  internal::locale_ref locale_;
+    FMT_CONSTEXPR void on_general() {}
+    FMT_CONSTEXPR void on_exp() {}
+    FMT_CONSTEXPR void on_fixed() {}
+    FMT_CONSTEXPR void on_percent() {}
+    FMT_CONSTEXPR void on_hex() {}
+    FMT_CONSTEXPR void on_num() {}
 
-  // Attempts to reserve space for n extra characters in the output range.
-  // Returns a pointer to the reserved range or a reference to out_.
-  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
-    return internal::reserve(out_, n);
-  }
+    FMT_CONSTEXPR void on_error() { ErrorHandler::on_error("invalid type specifier"); }
+  };
 
-  template <typename F> struct padded_int_writer {
-    size_t size_;
-    string_view prefix;
-    char_type fill;
-    std::size_t padding;
-    F f;
+  template <typename ErrorHandler> class char_specs_checker : public ErrorHandler
+  {
+  private:
+    char type_;
 
-    size_t size() const { return size_; }
-    size_t width() const { return size_; }
+  public:
+    FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh) : ErrorHandler(eh), type_(type) {}
 
-    template <typename It> void operator()(It&& it) const {
-      if (prefix.size() != 0)
-        it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
-      it = std::fill_n(it, padding, fill);
-      f(it);
+    FMT_CONSTEXPR void on_int()
+    {
+      handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
     }
+    FMT_CONSTEXPR void on_char() {}
   };
 
-  // Writes an integer in the format
-  //   <left-padding><prefix><numeric-padding><digits><right-padding>
-  // where <digits> are written by f(it).
-  template <typename F>
-  void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
-    std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
-    char_type fill = specs.fill[0];
-    std::size_t padding = 0;
-    if (specs.align == align::numeric) {
-      auto unsiged_width = internal::to_unsigned(specs.width);
-      if (unsiged_width > size) {
-        padding = unsiged_width - size;
-        size = unsiged_width;
-      }
-    } else if (specs.precision > num_digits) {
-      size = prefix.size() + internal::to_unsigned(specs.precision);
-      padding = internal::to_unsigned(specs.precision - num_digits);
-      fill = static_cast<char_type>('0');
-    }
-    if (specs.align == align::none) specs.align = align::right;
-    write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
-  }
-
-  // Writes a decimal integer.
-  template <typename Int> void write_decimal(Int value) {
-    auto abs_value = static_cast<uint32_or_64_t<Int>>(value);
-    bool is_negative = internal::is_negative(value);
-    if (is_negative) abs_value = 0 - abs_value;
-    int num_digits = internal::count_digits(abs_value);
-    auto&& it =
-        reserve((is_negative ? 1 : 0) + static_cast<size_t>(num_digits));
-    if (is_negative) *it++ = static_cast<char_type>('-');
-    it = internal::format_decimal<char_type>(it, abs_value, num_digits);
-  }
-
-  // The handle_int_type_spec handler that writes an integer.
-  template <typename Int, typename Specs> struct int_writer {
-    using unsigned_type = uint32_or_64_t<Int>;
-
-    basic_writer<Range>& writer;
-    const Specs& specs;
-    unsigned_type abs_value;
-    char prefix[4];
-    unsigned prefix_size;
-
-    string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
-    int_writer(basic_writer<Range>& w, Int value, const Specs& s)
-        : writer(w),
-          specs(s),
-          abs_value(static_cast<unsigned_type>(value)),
-          prefix_size(0) {
-      if (internal::is_negative(value)) {
-        prefix[0] = '-';
-        ++prefix_size;
-        abs_value = 0 - abs_value;
-      } else if (specs.sign != sign::none && specs.sign != sign::minus) {
-        prefix[0] = specs.sign == sign::plus ? '+' : ' ';
-        ++prefix_size;
-      }
-    }
+  template <typename ErrorHandler> class cstring_type_checker : public ErrorHandler
+  {
+  public:
+    FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
-    struct dec_writer {
-      unsigned_type abs_value;
-      int num_digits;
+    FMT_CONSTEXPR void on_string() {}
+    FMT_CONSTEXPR void on_pointer() {}
+  };
 
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+  template <typename Context> void arg_map<Context>::init(const basic_format_args<Context> &args)
+  {
+    if (map_)
+      return;
+    map_ = new entry[internal::to_unsigned(args.max_size())];
+    if (args.is_packed()) {
+      for (int i = 0;; ++i) {
+        internal::type arg_type = args.type(i);
+        if (arg_type == internal::none_type)
+          return;
+        if (arg_type == internal::named_arg_type)
+          push_back(args.values_[i]);
       }
-    };
-
-    void on_dec() {
-      int num_digits = internal::count_digits(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       dec_writer{abs_value, num_digits});
     }
+    for (int i = 0, n = args.max_size(); i < n; ++i) {
+      auto type = args.args_[i].type_;
+      if (type == internal::named_arg_type)
+        push_back(args.args_[i].value_);
+    }
+  }
 
-    struct hex_writer {
-      int_writer& self;
-      int num_digits;
+  // This template provides operations for formatting and writing data into a
+  // character range.
+  template <typename Range> class basic_writer
+  {
+  public:
+    using char_type    = typename Range::value_type;
+    using iterator     = typename Range::iterator;
+    using format_specs = basic_format_specs<char_type>;
+
+  private:
+    iterator             out_; // Output iterator.
+    internal::locale_ref locale_;
+
+    // Attempts to reserve space for n extra characters in the output range.
+    // Returns a pointer to the reserved range or a reference to out_.
+    auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n))
+    {
+      return internal::reserve(out_, n);
+    }
 
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_uint<4, char_type>(it, self.abs_value, num_digits,
-                                                 self.specs.type != 'x');
+    template <typename F> struct padded_int_writer
+    {
+      size_t      size_;
+      string_view prefix;
+      char_type   fill;
+      std::size_t padding;
+      F           f;
+
+      size_t size() const { return size_; }
+      size_t width() const { return size_; }
+
+      template <typename It> void operator()(It &&it) const
+      {
+        if (prefix.size() != 0)
+          it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
+        it = std::fill_n(it, padding, fill);
+        f(it);
       }
     };
 
-    void on_hex() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = specs.type;
+    // Writes an integer in the format
+    //   <left-padding><prefix><numeric-padding><digits><right-padding>
+    // where <digits> are written by f(it).
+    template <typename F>
+    void write_int(int num_digits, string_view prefix, format_specs specs, F f)
+    {
+      std::size_t size    = prefix.size() + internal::to_unsigned(num_digits);
+      char_type   fill    = specs.fill[0];
+      std::size_t padding = 0;
+      if (specs.align == align::numeric) {
+        auto unsiged_width = internal::to_unsigned(specs.width);
+        if (unsiged_width > size) {
+          padding = unsiged_width - size;
+          size    = unsiged_width;
+        }
       }
-      int num_digits = internal::count_digits<4>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       hex_writer{*this, num_digits});
+      else if (specs.precision > num_digits) {
+        size    = prefix.size() + internal::to_unsigned(specs.precision);
+        padding = internal::to_unsigned(specs.precision - num_digits);
+        fill    = static_cast<char_type>('0');
+      }
+      if (specs.align == align::none)
+        specs.align = align::right;
+      write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
     }
 
-    template <int BITS> struct bin_writer {
-      unsigned_type abs_value;
-      int num_digits;
+    // Writes a decimal integer.
+    template <typename Int> void write_decimal(Int value)
+    {
+      auto abs_value   = static_cast<uint32_or_64_or_128_t<Int>>(value);
+      bool is_negative = internal::is_negative(value);
+      // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
+      if (is_negative)
+        abs_value = ~abs_value + 1;
+      int    num_digits = internal::count_digits(abs_value);
+      auto &&it         = reserve((is_negative ? 1 : 0) + static_cast<size_t>(num_digits));
+      if (is_negative)
+        *it++ = static_cast<char_type>('-');
+      it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+    }
 
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_uint<BITS, char_type>(it, abs_value, num_digits);
+    // The handle_int_type_spec handler that writes an integer.
+    template <typename Int, typename Specs> struct int_writer
+    {
+      using unsigned_type = uint32_or_64_or_128_t<Int>;
+
+      basic_writer<Range> &writer;
+      const Specs &        specs;
+      unsigned_type        abs_value;
+      char                 prefix[4];
+      unsigned             prefix_size;
+
+      string_view get_prefix() const { return string_view(prefix, prefix_size); }
+
+      int_writer(basic_writer<Range> &w, Int value, const Specs &s)
+          : writer(w), specs(s), abs_value(static_cast<unsigned_type>(value)), prefix_size(0)
+      {
+        if (internal::is_negative(value)) {
+          prefix[0] = '-';
+          ++prefix_size;
+          abs_value = 0 - abs_value;
+        }
+        else if (specs.sign != sign::none && specs.sign != sign::minus) {
+          prefix[0] = specs.sign == sign::plus ? '+' : ' ';
+          ++prefix_size;
+        }
       }
-    };
 
-    void on_bin() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = static_cast<char>(specs.type);
+      struct dec_writer
+      {
+        unsigned_type abs_value;
+        int           num_digits;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+        }
+      };
+
+      void on_dec()
+      {
+        int num_digits = internal::count_digits(abs_value);
+        writer.write_int(num_digits, get_prefix(), specs, dec_writer{abs_value, num_digits});
       }
-      int num_digits = internal::count_digits<1>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<1>{abs_value, num_digits});
-    }
 
-    void on_oct() {
-      int num_digits = internal::count_digits<3>(abs_value);
-      if (specs.alt && specs.precision <= num_digits) {
-        // Octal prefix '0' is counted as a digit, so only add it if precision
-        // is not greater than the number of digits.
-        prefix[prefix_size++] = '0';
+      struct hex_writer
+      {
+        int_writer &self;
+        int         num_digits;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          it = internal::format_uint<4, char_type>(it, self.abs_value, num_digits,
+                                                   self.specs.type != 'x');
+        }
+      };
+
+      void on_hex()
+      {
+        if (specs.alt) {
+          prefix[prefix_size++] = '0';
+          prefix[prefix_size++] = specs.type;
+        }
+        int num_digits = internal::count_digits<4>(abs_value);
+        writer.write_int(num_digits, get_prefix(), specs, hex_writer{*this, num_digits});
       }
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<3>{abs_value, num_digits});
-    }
-
-    enum { sep_size = 1 };
-
-    struct num_writer {
-      unsigned_type abs_value;
-      int size;
-      char_type sep;
-
-      template <typename It> void operator()(It&& it) const {
-        basic_string_view<char_type> s(&sep, sep_size);
-        // Index of a decimal digit with the least significant digit having
-        // index 0.
-        unsigned digit_index = 0;
-        it = internal::format_decimal<char_type>(
-            it, abs_value, size, [s, &digit_index](char_type*& buffer) {
-              if (++digit_index % 3 != 0) return;
-              buffer -= s.size();
-              std::uninitialized_copy(s.data(), s.data() + s.size(),
-                                      internal::make_checked(buffer, s.size()));
-            });
+
+      template <int BITS> struct bin_writer
+      {
+        unsigned_type abs_value;
+        int           num_digits;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          it = internal::format_uint<BITS, char_type>(it, abs_value, num_digits);
+        }
+      };
+
+      void on_bin()
+      {
+        if (specs.alt) {
+          prefix[prefix_size++] = '0';
+          prefix[prefix_size++] = static_cast<char>(specs.type);
+        }
+        int num_digits = internal::count_digits<1>(abs_value);
+        writer.write_int(num_digits, get_prefix(), specs, bin_writer<1>{abs_value, num_digits});
       }
-    };
 
-    void on_num() {
-      char_type sep = internal::thousands_sep<char_type>(writer.locale_);
-      if (!sep) return on_dec();
-      int num_digits = internal::count_digits(abs_value);
-      int size = num_digits + sep_size * ((num_digits - 1) / 3);
-      writer.write_int(size, get_prefix(), specs,
-                       num_writer{abs_value, size, sep});
-    }
+      void on_oct()
+      {
+        int num_digits = internal::count_digits<3>(abs_value);
+        if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
+          // Octal prefix '0' is counted as a digit, so only add it if precision
+          // is not greater than the number of digits.
+          prefix[prefix_size++] = '0';
+        }
+        writer.write_int(num_digits, get_prefix(), specs, bin_writer<3>{abs_value, num_digits});
+      }
 
-    FMT_NORETURN void on_error() {
-      FMT_THROW(format_error("invalid type specifier"));
-    }
-  };
+      enum { sep_size = 1 };
+
+      struct num_writer
+      {
+        unsigned_type abs_value;
+        int           size;
+        char_type     sep;
+
+        template <typename It> void operator()(It &&it) const
+        {
+          basic_string_view<char_type> s(&sep, sep_size);
+          // Index of a decimal digit with the least significant digit having
+          // index 0.
+          unsigned digit_index = 0;
+          it                   = internal::format_decimal<char_type>(
+              it, abs_value, size, [s, &digit_index](char_type *&buffer) {
+                if (++digit_index % 3 != 0)
+                  return;
+                buffer -= s.size();
+                std::uninitialized_copy(s.data(), s.data() + s.size(),
+                                        internal::make_checked(buffer, s.size()));
+              });
+        }
+      };
+
+      void on_num()
+      {
+        char_type sep = internal::thousands_sep<char_type>(writer.locale_);
+        if (!sep)
+          return on_dec();
+        int num_digits = internal::count_digits(abs_value);
+        int size       = num_digits + sep_size * ((num_digits - 1) / 3);
+        writer.write_int(size, get_prefix(), specs, num_writer{abs_value, size, sep});
+      }
 
-  enum { inf_size = 3 };  // This is an enum to workaround a bug in MSVC.
+      FMT_NORETURN void on_error() { FMT_THROW(format_error("invalid type specifier")); }
+    };
 
-  struct inf_or_nan_writer {
-    char sign;
-    bool as_percentage;
-    const char* str;
+    enum { inf_size = 3 }; // This is an enum to workaround a bug in MSVC.
 
-    size_t size() const {
-      return static_cast<std::size_t>(inf_size + (sign ? 1 : 0) +
-                                      (as_percentage ? 1 : 0));
-    }
-    size_t width() const { return size(); }
+    struct inf_or_nan_writer
+    {
+      sign_t      sign;
+      bool        as_percentage;
+      const char *str;
 
-    template <typename It> void operator()(It&& it) const {
-      if (sign) *it++ = static_cast<char_type>(sign);
-      it = internal::copy_str<char_type>(
-          str, str + static_cast<std::size_t>(inf_size), it);
-      if (as_percentage) *it++ = static_cast<char_type>('%');
-    }
-  };
+      size_t size() const
+      {
+        return static_cast<std::size_t>(inf_size + (sign ? 1 : 0) + (as_percentage ? 1 : 0));
+      }
+      size_t width() const { return size(); }
+
+      template <typename It> void operator()(It &&it) const
+      {
+        if (sign)
+          *it++ = static_cast<char_type>(data::signs[sign]);
+        it = internal::copy_str<char_type>(str, str + static_cast<std::size_t>(inf_size), it);
+        if (as_percentage)
+          *it++ = static_cast<char_type>('%');
+      }
+    };
 
-  struct double_writer {
-    char sign;
-    internal::buffer<char>& buffer;
-    char* decimal_point_pos;
-    char_type decimal_point;
+    struct double_writer
+    {
+      sign_t                  sign;
+      internal::buffer<char> &buffer;
+      char *                  decimal_point_pos;
+      char_type               decimal_point;
+
+      size_t size() const { return buffer.size() + (sign ? 1 : 0); }
+      size_t width() const { return size(); }
+
+      template <typename It> void operator()(It &&it)
+      {
+        if (sign)
+          *it++ = static_cast<char_type>(data::signs[sign]);
+        auto begin = buffer.begin();
+        if (decimal_point_pos) {
+          it    = internal::copy_str<char_type>(begin, decimal_point_pos, it);
+          *it++ = decimal_point;
+          begin = decimal_point_pos + 1;
+        }
+        it = internal::copy_str<char_type>(begin, buffer.end(), it);
+      }
+    };
 
-    size_t size() const { return buffer.size() + (sign ? 1 : 0); }
-    size_t width() const { return size(); }
+    template <typename Char> struct str_writer
+    {
+      const Char *s;
+      size_t      size_;
 
-    template <typename It> void operator()(It&& it) {
-      if (sign) *it++ = static_cast<char_type>(sign);
-      auto begin = buffer.begin();
-      if (decimal_point_pos) {
-        it = internal::copy_str<char_type>(begin, decimal_point_pos, it);
-        *it++ = decimal_point;
-        begin = decimal_point_pos + 1;
+      size_t size() const { return size_; }
+      size_t width() const
+      {
+        return internal::count_code_points(basic_string_view<Char>(s, size_));
       }
-      it = internal::copy_str<char_type>(begin, buffer.end(), it);
-    }
-  };
 
-  class grisu_writer {
-   private:
-    internal::buffer<char>& digits_;
-    size_t size_;
-    char sign_;
-    int exp_;
-    internal::gen_digits_params params_;
-    char_type decimal_point_;
-
-   public:
-    grisu_writer(char sign, internal::buffer<char>& digits, int exp,
-                 const internal::gen_digits_params& params,
-                 char_type decimal_point)
-        : digits_(digits),
-          sign_(sign),
-          exp_(exp),
-          params_(params),
-          decimal_point_(decimal_point) {
-      int num_digits = static_cast<int>(digits.size());
-      int full_exp = num_digits + exp - 1;
-      int precision = params.num_digits > 0 ? params.num_digits : 11;
-      params_.fixed |= full_exp >= -4 && full_exp < precision;
-      auto it = internal::grisu_prettify<char>(
-          digits.data(), num_digits, exp, internal::counting_iterator<char>(),
-          params_, '.');
-      size_ = it.count();
-    }
+      template <typename It> void operator()(It &&it) const
+      {
+        it = internal::copy_str<char_type>(s, s + size_, it);
+      }
+    };
 
-    size_t size() const { return size_ + (sign_ ? 1 : 0); }
-    size_t width() const { return size(); }
+    template <typename UIntPtr> struct pointer_writer
+    {
+      UIntPtr value;
+      int     num_digits;
 
-    template <typename It> void operator()(It&& it) {
-      if (sign_) *it++ = static_cast<char_type>(sign_);
-      int num_digits = static_cast<int>(digits_.size());
-      it = internal::grisu_prettify<char_type>(digits_.data(), num_digits, exp_,
-                                               it, params_, decimal_point_);
-    }
-  };
+      size_t size() const { return to_unsigned(num_digits) + 2; }
+      size_t width() const { return size(); }
 
-  template <typename Char> struct str_writer {
-    const Char* s;
-    size_t size_;
+      template <typename It> void operator()(It &&it) const
+      {
+        *it++ = static_cast<char_type>('0');
+        *it++ = static_cast<char_type>('x');
+        it    = internal::format_uint<4, char_type>(it, value, num_digits);
+      }
+    };
 
-    size_t size() const { return size_; }
-    size_t width() const {
-      return internal::count_code_points(basic_string_view<Char>(s, size_));
+  public:
+    /** Constructs a ``basic_writer`` object. */
+    explicit basic_writer(Range out, internal::locale_ref loc = internal::locale_ref())
+        : out_(out.begin()), locale_(loc)
+    {
     }
 
-    template <typename It> void operator()(It&& it) const {
-      it = internal::copy_str<char_type>(s, s + size_, it);
+    iterator out() const { return out_; }
+
+    // Writes a value in the format
+    //   <left-padding><value><right-padding>
+    // where <value> is written by f(it).
+    template <typename F> void write_padded(const format_specs &specs, F &&f)
+    {
+      // User-perceived width (in code points).
+      unsigned width           = to_unsigned(specs.width);
+      size_t   size            = f.size(); // The number of code units.
+      size_t   num_code_points = width != 0 ? f.width() : size;
+      if (width <= num_code_points)
+        return f(reserve(size));
+      auto &&     it      = reserve(width + (size - num_code_points));
+      char_type   fill    = specs.fill[0];
+      std::size_t padding = width - num_code_points;
+      if (specs.align == align::right) {
+        it = std::fill_n(it, padding, fill);
+        f(it);
+      }
+      else if (specs.align == align::center) {
+        std::size_t left_padding = padding / 2;
+        it                       = std::fill_n(it, left_padding, fill);
+        f(it);
+        it = std::fill_n(it, padding - left_padding, fill);
+      }
+      else {
+        f(it);
+        it = std::fill_n(it, padding, fill);
+      }
     }
-  };
-
-  template <typename UIntPtr> struct pointer_writer {
-    UIntPtr value;
-    int num_digits;
 
-    size_t size() const { return to_unsigned(num_digits) + 2; }
-    size_t width() const { return size(); }
-
-    template <typename It> void operator()(It&& it) const {
-      *it++ = static_cast<char_type>('0');
-      *it++ = static_cast<char_type>('x');
-      it = internal::format_uint<4, char_type>(it, value, num_digits);
-    }
-  };
+    void write(int value) { write_decimal(value); }
+    void write(long value) { write_decimal(value); }
+    void write(long long value) { write_decimal(value); }
 
- public:
-  /** Constructs a ``basic_writer`` object. */
-  explicit basic_writer(Range p_out,
-                        internal::locale_ref loc = internal::locale_ref())
-      : out_(p_out.begin()), locale_(loc) {}
-
-  iterator out() const { return out_; }
-
-  // Writes a value in the format
-  //   <left-padding><value><right-padding>
-  // where <value> is written by f(it).
-  template <typename F> void write_padded(const format_specs& specs, F&& f) {
-    // User-perceived width (in code points).
-    unsigned width = to_unsigned(specs.width);
-    size_t size = f.size();  // The number of code units.
-    size_t num_code_points = width != 0 ? f.width() : size;
-    if (width <= num_code_points) return f(reserve(size));
-    auto&& it = reserve(width + (size - num_code_points));
-    char_type fill = specs.fill[0];
-    std::size_t padding = width - num_code_points;
-    if (specs.align == align::right) {
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    } else if (specs.align == align::center) {
-      std::size_t left_padding = padding / 2;
-      it = std::fill_n(it, left_padding, fill);
-      f(it);
-      it = std::fill_n(it, padding - left_padding, fill);
-    } else {
-      f(it);
-      it = std::fill_n(it, padding, fill);
-    }
-  }
-
-  void write(int value) { write_decimal(value); }
-  void write(long value) { write_decimal(value); }
-  void write(long long value) { write_decimal(value); }
-
-  void write(unsigned value) { write_decimal(value); }
-  void write(unsigned long value) { write_decimal(value); }
-  void write(unsigned long long value) { write_decimal(value); }
-
-  // Writes a formatted integer.
-  template <typename T, typename Spec>
-  void write_int(T value, const Spec& spec) {
-    internal::handle_int_type_spec(spec.type,
-                                   int_writer<T, Spec>(*this, value, spec));
-  }
-
-  void write(double value, const format_specs& specs = format_specs()) {
-    write_double(value, specs);
-  }
+    void write(unsigned value) { write_decimal(value); }
+    void write(unsigned long value) { write_decimal(value); }
+    void write(unsigned long long value) { write_decimal(value); }
 
-  /**
-    \rst
-    Formats *value* using the general format for floating-point numbers
-    (``'g'``) and writes it to the buffer.
-    \endrst
-   */
-  void write(long double value, const format_specs& specs = format_specs()) {
-    write_double(value, specs);
-  }
+#if FMT_USE_INT128
+    void write(int128_t value) { write_decimal(value); }
+    void write(uint128_t value) { write_decimal(value); }
+#endif
 
-  // Formats a floating-point number (double or long double).
-  template <typename T, bool USE_GRISU = fmt::internal::use_grisu<T>()>
-  void write_double(T value, const format_specs& specs);
+    // Writes a formatted integer.
+    template <typename T, typename Spec> void write_int(T value, const Spec &spec)
+    {
+      internal::handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
+    }
 
-  /** Writes a character to the buffer. */
-  void write(char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
+    void write(float value, const format_specs &specs = format_specs()) { write_fp(value, specs); }
 
-  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
-  void write(Char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
+    void write(double value, const format_specs &specs = format_specs()) { write_fp(value, specs); }
 
-  /**
-    \rst
-    Writes *value* to the buffer.
-    \endrst
-   */
-  void write(string_view value) {
-    auto&& it = reserve(value.size());
-    it = internal::copy_str<char_type>(value.begin(), value.end(), it);
-  }
-  void write(wstring_view value) {
-    static_assert(std::is_same<char_type, wchar_t>::value, "");
-    auto&& it = reserve(value.size());
-    it = std::copy(value.begin(), value.end(), it);
-  }
+    /**
+      \rst
+      Formats *value* using the general format for floating-point numbers
+      (``'g'``) and writes it to the buffer.
+      \endrst
+     */
+    void write(long double value, const format_specs &specs = format_specs())
+    {
+      write_fp(value, specs);
+    }
 
-  // Writes a formatted string.
-  template <typename Char>
-  void write(const Char* s, std::size_t size, const format_specs& specs) {
-    write_padded(specs, str_writer<Char>{s, size});
-  }
+    // Formats a floating-point number (float, double, or long double).
+    template <typename T, bool USE_GRISU = fmt::internal::use_grisu<T>()>
+    void write_fp(T value, const format_specs &specs);
 
-  template <typename Char>
-  void write(basic_string_view<Char> s,
-             const format_specs& specs = format_specs()) {
-    const Char* data = s.data();
-    std::size_t size = s.size();
-    if (specs.precision >= 0 && internal::to_unsigned(specs.precision) < size)
-      size = internal::to_unsigned(specs.precision);
-    write(data, size, specs);
-  }
+    /** Writes a character to the buffer. */
+    void write(char value)
+    {
+      auto &&it = reserve(1);
+      *it++     = value;
+    }
 
-  template <typename UIntPtr>
-  void write_pointer(UIntPtr value, const format_specs* specs) {
-    int num_digits = internal::count_digits<4>(value);
-    auto pw = pointer_writer<UIntPtr>{value, num_digits};
-    if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
-    format_specs specs_copy = *specs;
-    if (specs_copy.align == align::none) specs_copy.align = align::right;
-    write_padded(specs_copy, pw);
-  }
-};
+    template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
+    void write(Char value)
+    {
+      auto &&it = reserve(1);
+      *it++     = value;
+    }
 
-using writer = basic_writer<buffer_range<char>>;
+    /**
+      \rst
+      Writes *value* to the buffer.
+      \endrst
+     */
+    void write(string_view value)
+    {
+      auto &&it = reserve(value.size());
+      it        = internal::copy_str<char_type>(value.begin(), value.end(), it);
+    }
+    void write(wstring_view value)
+    {
+      static_assert(std::is_same<char_type, wchar_t>::value, "");
+      auto &&it = reserve(value.size());
+      it        = std::copy(value.begin(), value.end(), it);
+    }
 
-template <typename Range, typename ErrorHandler = internal::error_handler>
-class arg_formatter_base {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
+    // Writes a formatted string.
+    template <typename Char> void write(const Char *s, std::size_t size, const format_specs &specs)
+    {
+      write_padded(specs, str_writer<Char>{s, size});
+    }
 
- private:
-  using writer_type = basic_writer<Range>;
-  writer_type writer_;
-  format_specs* specs_;
+    template <typename Char>
+    void write(basic_string_view<Char> s, const format_specs &specs = format_specs())
+    {
+      const Char *data = s.data();
+      std::size_t size = s.size();
+      if (specs.precision >= 0 && internal::to_unsigned(specs.precision) < size)
+        size = internal::to_unsigned(specs.precision);
+      write(data, size, specs);
+    }
 
-  struct char_writer {
-    char_type value;
+    template <typename UIntPtr> void write_pointer(UIntPtr value, const format_specs *specs)
+    {
+      int  num_digits = internal::count_digits<4>(value);
+      auto pw         = pointer_writer<UIntPtr>{value, num_digits};
+      if (!specs)
+        return pw(reserve(to_unsigned(num_digits) + 2));
+      format_specs specs_copy = *specs;
+      if (specs_copy.align == align::none)
+        specs_copy.align = align::right;
+      write_padded(specs_copy, pw);
+    }
+  };
 
-    size_t size() const { return 1; }
-    size_t width() const { return 1; }
+  using writer = basic_writer<buffer_range<char>>;
 
-    template <typename It> void operator()(It&& it) const { *it++ = value; }
+  template <typename T> struct is_integral : std::is_integral<T>
+  {
+  };
+  template <> struct is_integral<int128_t> : std::true_type
+  {
+  };
+  template <> struct is_integral<uint128_t> : std::true_type
+  {
   };
 
-  void write_char(char_type value) {
-    if (specs_)
-      writer_.write_padded(*specs_, char_writer{value});
-    else
-      writer_.write(value);
-  }
-
-  void write_pointer(const void* p) {
-    writer_.write_pointer(internal::bit_cast<internal::uintptr_t>(p), specs_);
-  }
+  template <typename Range, typename ErrorHandler = internal::error_handler>
+  class arg_formatter_base
+  {
+  public:
+    using char_type    = typename Range::value_type;
+    using iterator     = typename Range::iterator;
+    using format_specs = basic_format_specs<char_type>;
 
- protected:
-  writer_type& writer() { return writer_; }
-  FMT_DEPRECATED format_specs* spec() { return specs_; }
-  format_specs* specs() { return specs_; }
-  iterator out() { return writer_.out(); }
+  private:
+    using writer_type = basic_writer<Range>;
+    writer_type   writer_;
+    format_specs *specs_;
 
-  void write(bool value) {
-    string_view sv(value ? "true" : "false");
-    specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-  }
+    struct char_writer
+    {
+      char_type value;
 
-  void write(const char_type* value) {
-    if (!value) {
-      FMT_THROW(format_error("string pointer is null"));
-    } else {
-      auto length = std::char_traits<char_type>::length(value);
-      basic_string_view<char_type> sv(value, length);
-      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-    }
-  }
+      size_t size() const { return 1; }
+      size_t width() const { return 1; }
 
- public:
-  arg_formatter_base(Range r, format_specs* s, locale_ref loc)
-      : writer_(r, loc), specs_(s) {}
+      template <typename It> void operator()(It &&it) const { *it++ = value; }
+    };
 
-  iterator operator()(monostate) {
-    FMT_ASSERT(false, "invalid argument type");
-    return out();
-  }
+    void write_char(char_type value)
+    {
+      if (specs_)
+        writer_.write_padded(*specs_, char_writer{value});
+      else
+        writer_.write(value);
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  iterator operator()(T value) {
-    if (specs_)
-      writer_.write_int(value, *specs_);
-    else
-      writer_.write(value);
-    return out();
-  }
+    void write_pointer(const void *p)
+    {
+      writer_.write_pointer(internal::bit_cast<internal::uintptr_t>(p), specs_);
+    }
 
-  iterator operator()(char_type value) {
-    internal::handle_char_specs(
-        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
-    return out();
-  }
+  protected:
+    writer_type &  writer() { return writer_; }
+    FMT_DEPRECATED format_specs *spec() { return specs_; }
+    format_specs *               specs() { return specs_; }
+    iterator                     out() { return writer_.out(); }
 
-  iterator operator()(bool value) {
-    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
-    write(value != 0);
-    return out();
-  }
+    void write(bool value)
+    {
+      string_view sv(value ? "true" : "false");
+      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    writer_.write_double(value, specs_ ? *specs_ : format_specs());
-    return out();
-  }
+    void write(const char_type *value)
+    {
+      if (!value) {
+        FMT_THROW(format_error("string pointer is null"));
+      }
+      else {
+        auto                         length = std::char_traits<char_type>::length(value);
+        basic_string_view<char_type> sv(value, length);
+        specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+      }
+    }
 
-  struct char_spec_handler : ErrorHandler {
-    arg_formatter_base& formatter;
-    char_type value;
+  public:
+    arg_formatter_base(Range r, format_specs *s, locale_ref loc) : writer_(r, loc), specs_(s) {}
 
-    char_spec_handler(arg_formatter_base& f, char_type val)
-        : formatter(f), value(val) {}
+    iterator operator()(monostate)
+    {
+      FMT_ASSERT(false, "invalid argument type");
+      return out();
+    }
 
-    void on_int() {
-      if (formatter.specs_)
-        formatter.writer_.write_int(value, *formatter.specs_);
+    template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> iterator operator()(T value)
+    {
+      if (specs_)
+        writer_.write_int(value, *specs_);
       else
-        formatter.writer_.write(value);
+        writer_.write(value);
+      return out();
     }
-    void on_char() { formatter.write_char(value); }
-  };
-
-  struct cstring_spec_handler : internal::error_handler {
-    arg_formatter_base& formatter;
-    const char_type* value;
-
-    cstring_spec_handler(arg_formatter_base& f, const char_type* val)
-        : formatter(f), value(val) {}
 
-    void on_string() { formatter.write(value); }
-    void on_pointer() { formatter.write_pointer(value); }
-  };
-
-  iterator operator()(const char_type* value) {
-    if (!specs_) return write(value), out();
-    internal::handle_cstring_type_spec(specs_->type,
-                                       cstring_spec_handler(*this, value));
-    return out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    if (specs_) {
-      internal::check_string_type_spec(specs_->type, internal::error_handler());
-      writer_.write(value, *specs_);
-    } else {
-      writer_.write(value);
+    iterator operator()(char_type value)
+    {
+      internal::handle_char_specs(specs_, char_spec_handler(*this, static_cast<char_type>(value)));
+      return out();
     }
-    return out();
-  }
-
-  iterator operator()(const void* value) {
-    if (specs_)
-      check_pointer_type_spec(specs_->type, internal::error_handler());
-    write_pointer(value);
-    return out();
-  }
-};
 
-template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
+    iterator operator()(bool value)
+    {
+      if (specs_ && specs_->type)
+        return (*this)(value ? 1 : 0);
+      write(value != 0);
+      return out();
+    }
 
-// Parses the range [begin, end) as an unsigned integer. This function assumes
-// that the range is non-empty and the first character is a digit.
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
-                                        ErrorHandler&& eh) {
-  assert(begin != end && '0' <= *begin && *begin <= '9');
-  if (*begin == '0') {
-    ++begin;
-    return 0;
-  }
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  constexpr unsigned max_int = (std::numeric_limits<int>::max)();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
+    template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+    iterator operator()(T value)
+    {
+      writer_.write_fp(value, specs_ ? *specs_ : format_specs());
+      return out();
     }
-    value = value * 10 + unsigned(*begin - '0');
-    ++begin;
-  } while (begin != end && '0' <= *begin && *begin <= '9');
-  if (value > max_int) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
 
-template <typename Context> class custom_formatter {
- private:
-  using char_type = typename Context::char_type;
+    struct char_spec_handler : ErrorHandler
+    {
+      arg_formatter_base &formatter;
+      char_type           value;
 
-  basic_parse_context<char_type>& parse_ctx_;
-  Context& ctx_;
+      char_spec_handler(arg_formatter_base &f, char_type val) : formatter(f), value(val) {}
 
- public:
-  explicit custom_formatter(basic_parse_context<char_type>& parse_ctx,
-                            Context& ctx)
-      : parse_ctx_(parse_ctx), ctx_(ctx) {}
+      void on_int()
+      {
+        if (formatter.specs_)
+          formatter.writer_.write_int(value, *formatter.specs_);
+        else
+          formatter.writer_.write(value);
+      }
+      void on_char() { formatter.write_char(value); }
+    };
 
-  bool operator()(typename basic_format_arg<Context>::handle h) const {
-    h.format(parse_ctx_, ctx_);
-    return true;
-  }
+    struct cstring_spec_handler : internal::error_handler
+    {
+      arg_formatter_base &formatter;
+      const char_type *   value;
 
-  template <typename T> bool operator()(T) const { return false; }
-};
+      cstring_spec_handler(arg_formatter_base &f, const char_type *val) : formatter(f), value(val)
+      {
+      }
 
-template <typename T>
-using is_integer =
-    bool_constant<std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-                  !std::is_same<T, char>::value &&
-                  !std::is_same<T, wchar_t>::value>;
+      void on_string() { formatter.write(value); }
+      void on_pointer() { formatter.write_pointer(value); }
+    };
+
+    iterator operator()(const char_type *value)
+    {
+      if (!specs_)
+        return write(value), out();
+      internal::handle_cstring_type_spec(specs_->type, cstring_spec_handler(*this, value));
+      return out();
+    }
 
-template <typename ErrorHandler> class width_checker {
- public:
-  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
+    iterator operator()(basic_string_view<char_type> value)
+    {
+      if (specs_) {
+        internal::check_string_type_spec(specs_->type, internal::error_handler());
+        writer_.write(value, *specs_);
+      }
+      else {
+        writer_.write(value);
+      }
+      return out();
+    }
 
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative width");
-    return static_cast<unsigned long long>(value);
-  }
+    iterator operator()(const void *value)
+    {
+      if (specs_)
+        check_pointer_type_spec(specs_->type, internal::error_handler());
+      write_pointer(value);
+      return out();
+    }
+  };
 
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("width is not integer");
-    return 0;
+  template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c)
+  {
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
   }
 
- private:
-  ErrorHandler& handler_;
-};
+  // Parses the range [begin, end) as an unsigned integer. This function assumes
+  // that the range is non-empty and the first character is a digit.
+  template <typename Char, typename ErrorHandler>
+  FMT_CONSTEXPR int parse_nonnegative_int(const Char *&begin, const Char *end, ErrorHandler &&eh)
+  {
+    assert(begin != end && '0' <= *begin && *begin <= '9');
+    if (*begin == '0') {
+      ++begin;
+      return 0;
+    }
+    unsigned value = 0;
+    // Convert to unsigned to prevent a warning.
+    constexpr unsigned max_int = max_value<int>();
+    unsigned           big     = max_int / 10;
+    do {
+      // Check for overflow.
+      if (value > big) {
+        value = max_int + 1;
+        break;
+      }
+      value = value * 10 + unsigned(*begin - '0');
+      ++begin;
+    } while (begin != end && '0' <= *begin && *begin <= '9');
+    if (value > max_int)
+      eh.on_error("number is too big");
+    return static_cast<int>(value);
+  }
+
+  template <typename Context> class custom_formatter
+  {
+  private:
+    using char_type = typename Context::char_type;
+
+    basic_parse_context<char_type> &parse_ctx_;
+    Context &                       ctx_;
+
+  public:
+    explicit custom_formatter(basic_parse_context<char_type> &parse_ctx, Context &ctx)
+        : parse_ctx_(parse_ctx), ctx_(ctx)
+    {
+    }
 
-template <typename ErrorHandler> class precision_checker {
- public:
-  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
+    bool operator()(typename basic_format_arg<Context>::handle h) const
+    {
+      h.format(parse_ctx_, ctx_);
+      return true;
+    }
 
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative precision");
-    return static_cast<unsigned long long>(value);
-  }
+    template <typename T> bool operator()(T) const { return false; }
+  };
 
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("precision is not integer");
-    return 0;
-  }
+  template <typename T>
+  using is_integer =
+      bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
+                    !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value>;
+
+  template <typename ErrorHandler> class width_checker
+  {
+  public:
+    explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) : handler_(eh) {}
+
+    template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T value)
+    {
+      if (is_negative(value))
+        handler_.on_error("negative width");
+      return static_cast<unsigned long long>(value);
+    }
 
- private:
-  ErrorHandler& handler_;
-};
+    template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T)
+    {
+      handler_.on_error("width is not integer");
+      return 0;
+    }
 
-// A format specifier handler that sets fields in basic_format_specs.
-template <typename Char> class specs_setter {
- public:
-  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
-      : specs_(specs) {}
+  private:
+    ErrorHandler &handler_;
+  };
 
-  FMT_CONSTEXPR specs_setter(const specs_setter& other)
-      : specs_(other.specs_) {}
+  template <typename ErrorHandler> class precision_checker
+  {
+  public:
+    explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) : handler_(eh) {}
+
+    template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T value)
+    {
+      if (is_negative(value))
+        handler_.on_error("negative precision");
+      return static_cast<unsigned long long>(value);
+    }
 
-  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
-  FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; }
-  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
-  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
-  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
-  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
+    template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+    FMT_CONSTEXPR unsigned long long operator()(T)
+    {
+      handler_.on_error("precision is not integer");
+      return 0;
+    }
 
-  FMT_CONSTEXPR void on_zero() {
-    specs_.align = align::numeric;
-    specs_.fill[0] = Char('0');
-  }
+  private:
+    ErrorHandler &handler_;
+  };
 
-  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
-  FMT_CONSTEXPR void on_precision(int precision) {
-    specs_.precision = precision;
-  }
-  FMT_CONSTEXPR void end_precision() {}
+  // A format specifier handler that sets fields in basic_format_specs.
+  template <typename Char> class specs_setter
+  {
+  public:
+    explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs) : specs_(specs) {}
+
+    FMT_CONSTEXPR specs_setter(const specs_setter &other) : specs_(other.specs_) {}
+
+    FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
+    FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; }
+    FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
+    FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
+    FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
+    FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
+
+    FMT_CONSTEXPR void on_zero()
+    {
+      specs_.align   = align::numeric;
+      specs_.fill[0] = Char('0');
+    }
 
-  FMT_CONSTEXPR void on_type(Char type) {
-    specs_.type = static_cast<char>(type);
-  }
+    FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
+    FMT_CONSTEXPR void on_precision(int precision) { specs_.precision = precision; }
+    FMT_CONSTEXPR void end_precision() {}
 
- protected:
-  basic_format_specs<Char>& specs_;
-};
+    FMT_CONSTEXPR void on_type(Char type) { specs_.type = static_cast<char>(type); }
 
-template <typename ErrorHandler> class numeric_specs_checker {
- public:
-  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
-      : error_handler_(eh), arg_type_(arg_type) {}
+  protected:
+    basic_format_specs<Char> &specs_;
+  };
 
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic(arg_type_))
-      error_handler_.on_error("format specifier requires numeric argument");
-  }
+  template <typename ErrorHandler> class numeric_specs_checker
+  {
+  public:
+    FMT_CONSTEXPR numeric_specs_checker(ErrorHandler &eh, internal::type arg_type)
+        : error_handler_(eh), arg_type_(arg_type)
+    {
+    }
 
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
-      error_handler_.on_error("format specifier requires signed argument");
+    FMT_CONSTEXPR void require_numeric_argument()
+    {
+      if (!is_arithmetic_type(arg_type_))
+        error_handler_.on_error("format specifier requires numeric argument");
     }
-  }
 
-  FMT_CONSTEXPR void check_precision() {
-    if (is_integral(arg_type_) || arg_type_ == internal::pointer_type)
-      error_handler_.on_error("precision not allowed for this argument type");
-  }
+    FMT_CONSTEXPR void check_sign()
+    {
+      require_numeric_argument();
+      if (is_integral_type(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type &&
+          arg_type_ != internal::char_type) {
+        error_handler_.on_error("format specifier requires signed argument");
+      }
+    }
 
- private:
-  ErrorHandler& error_handler_;
-  internal::type arg_type_;
-};
+    FMT_CONSTEXPR void check_precision()
+    {
+      if (is_integral_type(arg_type_) || arg_type_ == internal::pointer_type)
+        error_handler_.on_error("precision not allowed for this argument type");
+    }
 
-// A format specifier handler that checks if specifiers are consistent with the
-// argument type.
-template <typename Handler> class specs_checker : public Handler {
- public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
-      : Handler(handler), checker_(*this, arg_type) {}
+  private:
+    ErrorHandler & error_handler_;
+    internal::type arg_type_;
+  };
 
-  FMT_CONSTEXPR specs_checker(const specs_checker& other)
-      : Handler(other), checker_(*this, other.arg_type_) {}
+  // A format specifier handler that checks if specifiers are consistent with the
+  // argument type.
+  template <typename Handler> class specs_checker : public Handler
+  {
+  public:
+    FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type)
+        : Handler(handler), checker_(*this, arg_type)
+    {
+    }
 
-  FMT_CONSTEXPR void on_align(align_t align) {
-    if (align == align::numeric) checker_.require_numeric_argument();
-    Handler::on_align(align);
-  }
+    FMT_CONSTEXPR specs_checker(const specs_checker &other)
+        : Handler(other), checker_(*this, other.arg_type_)
+    {
+    }
 
-  FMT_CONSTEXPR void on_plus() {
-    checker_.check_sign();
-    Handler::on_plus();
-  }
+    FMT_CONSTEXPR void on_align(align_t align)
+    {
+      if (align == align::numeric)
+        checker_.require_numeric_argument();
+      Handler::on_align(align);
+    }
 
-  FMT_CONSTEXPR void on_minus() {
-    checker_.check_sign();
-    Handler::on_minus();
-  }
+    FMT_CONSTEXPR void on_plus()
+    {
+      checker_.check_sign();
+      Handler::on_plus();
+    }
 
-  FMT_CONSTEXPR void on_space() {
-    checker_.check_sign();
-    Handler::on_space();
-  }
+    FMT_CONSTEXPR void on_minus()
+    {
+      checker_.check_sign();
+      Handler::on_minus();
+    }
 
-  FMT_CONSTEXPR void on_hash() {
-    checker_.require_numeric_argument();
-    Handler::on_hash();
-  }
+    FMT_CONSTEXPR void on_space()
+    {
+      checker_.check_sign();
+      Handler::on_space();
+    }
 
-  FMT_CONSTEXPR void on_zero() {
-    checker_.require_numeric_argument();
-    Handler::on_zero();
-  }
+    FMT_CONSTEXPR void on_hash()
+    {
+      checker_.require_numeric_argument();
+      Handler::on_hash();
+    }
 
-  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
+    FMT_CONSTEXPR void on_zero()
+    {
+      checker_.require_numeric_argument();
+      Handler::on_zero();
+    }
 
- private:
-  numeric_specs_checker<Handler> checker_;
-};
+    FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
 
-template <template <typename> class Handler, typename T, typename FormatArg,
-          typename ErrorHandler>
-FMT_CONSTEXPR void set_dynamic_spec(T& value, FormatArg arg, ErrorHandler eh) {
-  unsigned long long big_value =
-      visit_format_arg(Handler<ErrorHandler>(eh), arg);
-  if (big_value > to_unsigned((std::numeric_limits<int>::max)()))
-    eh.on_error("number is too big");
-  value = static_cast<T>(big_value);
-}
+  private:
+    numeric_specs_checker<Handler> checker_;
+  };
 
-struct auto_id {};
+  template <template <typename> class Handler, typename FormatArg, typename ErrorHandler>
+  FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh)
+  {
+    unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
+    if (value > to_unsigned(max_value<int>()))
+      eh.on_error("number is too big");
+    return static_cast<int>(value);
+  }
 
-template <typename Context>
-FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
-  auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("argument index out of range");
-  return arg;
-}
+  struct auto_id
+  {
+  };
 
-// The standard format specifier handler with checking.
-template <typename ParseContext, typename Context>
-class specs_handler : public specs_setter<typename Context::char_type> {
- public:
-  using char_type = typename Context::char_type;
+  template <typename Context>
+  FMT_CONSTEXPR typename Context::format_arg get_arg(Context &ctx, int id)
+  {
+    auto arg = ctx.arg(id);
+    if (!arg)
+      ctx.on_error("argument index out of range");
+    return arg;
+  }
+
+  // The standard format specifier handler with checking.
+  template <typename ParseContext, typename Context>
+  class specs_handler : public specs_setter<typename Context::char_type>
+  {
+  public:
+    using char_type = typename Context::char_type;
+
+    FMT_CONSTEXPR specs_handler(basic_format_specs<char_type> &specs, ParseContext &parse_ctx,
+                                Context &ctx)
+        : specs_setter<char_type>(specs), parse_context_(parse_ctx), context_(ctx)
+    {
+    }
 
-  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
-                              ParseContext& parse_ctx, Context& ctx)
-      : specs_setter<char_type>(specs),
-        parse_context_(parse_ctx),
-        context_(ctx) {}
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+      this->specs_.width =
+          get_dynamic_spec<width_checker>(get_arg(arg_id), context_.error_handler());
+    }
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    set_dynamic_spec<width_checker>(this->specs_.width, get_arg(arg_id),
-                                    context_.error_handler());
-  }
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+      this->specs_.precision =
+          get_dynamic_spec<precision_checker>(get_arg(arg_id), context_.error_handler());
+    }
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    set_dynamic_spec<precision_checker>(this->specs_.precision, get_arg(arg_id),
-                                        context_.error_handler());
-  }
+    void on_error(const char *message) { context_.on_error(message); }
 
-  void on_error(const char* message) { context_.on_error(message); }
+  private:
+    // This is only needed for compatibility with gcc 4.4.
+    using format_arg = typename Context::format_arg;
 
- private:
-  // This is only needed for compatibility with gcc 4.4.
-  using format_arg = typename Context::format_arg;
+    FMT_CONSTEXPR format_arg get_arg(auto_id)
+    {
+      return internal::get_arg(context_, parse_context_.next_arg_id());
+    }
 
-  FMT_CONSTEXPR format_arg get_arg(auto_id) {
-    return internal::get_arg(context_, parse_context_.next_arg_id());
-  }
+    FMT_CONSTEXPR format_arg get_arg(int arg_id)
+    {
+      parse_context_.check_arg_id(arg_id);
+      return internal::get_arg(context_, arg_id);
+    }
 
-  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return internal::get_arg(context_, arg_id);
-  }
+    FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id)
+    {
+      parse_context_.check_arg_id(arg_id);
+      return context_.arg(arg_id);
+    }
 
-  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return context_.arg(arg_id);
-  }
+    ParseContext &parse_context_;
+    Context &     context_;
+  };
 
-  ParseContext& parse_context_;
-  Context& context_;
-};
+  enum class arg_id_kind { none, index, name };
 
-struct string_view_metadata {
-  FMT_CONSTEXPR string_view_metadata() : offset_(0u), size_(0u) {}
-  template <typename Char>
-  FMT_CONSTEXPR string_view_metadata(basic_string_view<Char> primary_string,
-                                     basic_string_view<Char> view)
-      : offset_(to_unsigned(view.data() - primary_string.data())),
-        size_(view.size()) {}
-  FMT_CONSTEXPR string_view_metadata(std::size_t offset, std::size_t size)
-      : offset_(offset), size_(size) {}
-  template <typename Char>
-  FMT_CONSTEXPR basic_string_view<Char> to_view(const Char* str) const {
-    return {str + offset_, size_};
-  }
-
-  std::size_t offset_;
-  std::size_t size_;
-};
+  // An argument reference.
+  template <typename Char> struct arg_ref
+  {
+    FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
+    FMT_CONSTEXPR explicit arg_ref(int index) : kind(arg_id_kind::index), val(index) {}
+    FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+        : kind(arg_id_kind::name), val(name)
+    {
+    }
 
-enum class arg_id_kind { none, index, name };
+    FMT_CONSTEXPR arg_ref &operator=(int idx)
+    {
+      kind      = arg_id_kind::index;
+      val.index = idx;
+      return *this;
+    }
 
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-  FMT_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMT_CONSTEXPR explicit arg_ref(string_view_metadata name)
-      : kind(arg_id_kind::name), val(name) {}
+    arg_id_kind kind;
+    union value {
+      FMT_CONSTEXPR value() : index(0u) {}
+      FMT_CONSTEXPR value(int id) : index(id) {}
+      FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
 
-  FMT_CONSTEXPR arg_ref& operator=(int idx) {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
+      int                     index;
+      basic_string_view<Char> name;
+    } val;
+  };
 
-  arg_id_kind kind;
-  union value {
-    FMT_CONSTEXPR value() : index(0u) {}
-    FMT_CONSTEXPR value(int id) : index(id) {}
-    FMT_CONSTEXPR value(string_view_metadata n) : name(n) {}
+  // Format specifiers with width and precision resolved at formatting rather
+  // than parsing time to allow re-using the same parsed specifiers with
+  // different sets of arguments (precompilation of format strings).
+  template <typename Char> struct dynamic_format_specs : basic_format_specs<Char>
+  {
+    arg_ref<Char> width_ref;
+    arg_ref<Char> precision_ref;
+  };
 
-    int index;
-    string_view_metadata name;
-  } val;
-};
+  // Format spec handler that saves references to arguments representing dynamic
+  // width and precision to be resolved at formatting time.
+  template <typename ParseContext>
+  class dynamic_specs_handler : public specs_setter<typename ParseContext::char_type>
+  {
+  public:
+    using char_type = typename ParseContext::char_type;
+
+    FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type> &specs, ParseContext &ctx)
+        : specs_setter<char_type>(specs), specs_(specs), context_(ctx)
+    {
+    }
 
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow re-using the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char>
-struct dynamic_format_specs : basic_format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
+    FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
+        : specs_setter<char_type>(other), specs_(other.specs_), context_(other.context_)
+    {
+    }
 
-// Format spec handler that saves references to arguments representing dynamic
-// width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler
-    : public specs_setter<typename ParseContext::char_type> {
- public:
-  using char_type = typename ParseContext::char_type;
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+      specs_.width_ref = make_arg_ref(arg_id);
+    }
 
-  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
-                                      ParseContext& ctx)
-      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+      specs_.precision_ref = make_arg_ref(arg_id);
+    }
 
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
-      : specs_setter<char_type>(other),
-        specs_(other.specs_),
-        context_(other.context_) {}
+    FMT_CONSTEXPR void on_error(const char *message) { context_.on_error(message); }
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    specs_.width_ref = make_arg_ref(arg_id);
-  }
+  private:
+    using arg_ref_type = arg_ref<char_type>;
 
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    specs_.precision_ref = make_arg_ref(arg_id);
-  }
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id)
+    {
+      context_.check_arg_id(arg_id);
+      return arg_ref_type(arg_id);
+    }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id)
+    {
+      return arg_ref_type(context_.next_arg_id());
+    }
 
- private:
-  using arg_ref_type = arg_ref<char_type>;
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id)
+    {
+      context_.check_arg_id(arg_id);
+      basic_string_view<char_type> format_str(context_.begin(),
+                                              to_unsigned(context_.end() - context_.begin()));
+      return arg_ref_type(arg_id);
+    }
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
-  }
+    dynamic_format_specs<char_type> &specs_;
+    ParseContext &                   context_;
+  };
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
-    return arg_ref_type(context_.next_arg_id());
+  template <typename Char, typename IDHandler>
+  FMT_CONSTEXPR const Char *parse_arg_id(const Char *begin, const Char *end, IDHandler &&handler)
+  {
+    assert(begin != end);
+    Char c = *begin;
+    if (c == '}' || c == ':')
+      return handler(), begin;
+    if (c >= '0' && c <= '9') {
+      int index = parse_nonnegative_int(begin, end, handler);
+      if (begin == end || (*begin != '}' && *begin != ':'))
+        return handler.on_error("invalid format string"), begin;
+      handler(index);
+      return begin;
+    }
+    if (!is_name_start(c))
+      return handler.on_error("invalid format string"), begin;
+    auto it = begin;
+    do {
+      ++it;
+    } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
+    handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
+    return it;
   }
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
-    context_.check_arg_id(arg_id);
-    basic_string_view<char_type> format_str(
-        context_.begin(), to_unsigned(context_.end() - context_.begin()));
-    const auto id_metadata = string_view_metadata(format_str, arg_id);
-    return arg_ref_type(id_metadata);
-  }
+  // Adapts SpecHandler to IDHandler API for dynamic width.
+  template <typename SpecHandler, typename Char> struct width_adapter
+  {
+    explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) : handler(h) {}
 
-  dynamic_format_specs<char_type>& specs_;
-  ParseContext& context_;
-};
+    FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) { handler.on_dynamic_width(id); }
 
-template <typename Char, typename IDHandler>
-FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
-                                       IDHandler&& handler) {
-  assert(begin != end);
-  Char c = *begin;
-  if (c == '}' || c == ':') return handler(), begin;
-  if (c >= '0' && c <= '9') {
-    int index = parse_nonnegative_int(begin, end, handler);
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      return handler.on_error("invalid format string"), begin;
-    handler(index);
-    return begin;
-  }
-  if (!is_name_start(c))
-    return handler.on_error("invalid format string"), begin;
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
-  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
-  return it;
-}
+    FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
 
-// Adapts SpecHandler to IDHandler API for dynamic width.
-template <typename SpecHandler, typename Char> struct width_adapter {
-  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
+    SpecHandler &handler;
+  };
 
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_width(id);
-  }
+  // Adapts SpecHandler to IDHandler API for dynamic precision.
+  template <typename SpecHandler, typename Char> struct precision_adapter
+  {
+    explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) : handler(h) {}
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
+    FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) { handler.on_dynamic_precision(id); }
 
-  SpecHandler& handler;
-};
+    FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
 
-// Adapts SpecHandler to IDHandler API for dynamic precision.
-template <typename SpecHandler, typename Char> struct precision_adapter {
-  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
+    SpecHandler &handler;
+  };
 
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_precision(id);
+  // Parses fill and alignment.
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_align(const Char *begin, const Char *end, Handler &&handler)
+  {
+    FMT_ASSERT(begin != end, "");
+    auto align = align::none;
+    int  i     = 0;
+    if (begin + 1 != end)
+      ++i;
+    do {
+      switch (static_cast<char>(begin[i])) {
+      case '<': align = align::left; break;
+      case '>': align = align::right; break;
+#if FMT_NUMERIC_ALIGN
+      case '=': align = align::numeric; break;
+#endif
+      case '^': align = align::center; break;
+      }
+      if (align != align::none) {
+        if (i > 0) {
+          auto c = *begin;
+          if (c == '{')
+            return handler.on_error("invalid fill character '{'"), begin;
+          begin += 2;
+          handler.on_fill(c);
+        }
+        else
+          ++begin;
+        handler.on_align(align);
+        break;
+      }
+    } while (i-- > 0);
+    return begin;
   }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_width(const Char *begin, const Char *end, Handler &&handler)
+  {
+    FMT_ASSERT(begin != end, "");
+    if ('0' <= *begin && *begin <= '9') {
+      handler.on_width(parse_nonnegative_int(begin, end, handler));
+    }
+    else if (*begin == '{') {
+      ++begin;
+      if (begin != end)
+        begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
+      if (begin == end || *begin != '}')
+        return handler.on_error("invalid format string"), begin;
+      ++begin;
+    }
+    return begin;
   }
 
-  SpecHandler& handler;
-};
+  template <typename Char, typename Handler>
+  FMT_CONSTEXPR const Char *parse_precision(const Char *begin, const Char *end, Handler &&handler)
+  {
+    ++begin;
+    auto c = begin != end ? *begin : Char();
+    if ('0' <= c && c <= '9') {
+      handler.on_precision(parse_nonnegative_int(begin, end, handler));
+    }
+    else if (c == '{') {
+      ++begin;
+      if (begin != end) {
+        begin = parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
+      }
+      if (begin == end || *begin++ != '}')
+        return handler.on_error("invalid format string"), begin;
+    }
+    else {
+      return handler.on_error("missing precision specifier"), begin;
+    }
+    handler.end_precision();
+    return begin;
+  }
 
-// Parses fill and alignment.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  auto align = align::none;
-  int i = 0;
-  if (begin + 1 != end) ++i;
-  do {
-    switch (static_cast<char>(begin[i])) {
-    case '<':
-      align = align::left;
-      break;
-    case '>':
-      align = align::right;
+  // Parses standard format specifiers and sends notifications about parsed
+  // components to handler.
+  template <typename Char, typename SpecHandler>
+  FMT_CONSTEXPR const Char *parse_format_specs(const Char *begin, const Char *end,
+                                               SpecHandler &&handler)
+  {
+    if (begin == end || *begin == '}')
+      return begin;
+
+    begin = parse_align(begin, end, handler);
+    if (begin == end)
+      return begin;
+
+    // Parse sign.
+    switch (static_cast<char>(*begin)) {
+    case '+':
+      handler.on_plus();
+      ++begin;
       break;
-    case '=':
-      align = align::numeric;
+    case '-':
+      handler.on_minus();
+      ++begin;
       break;
-    case '^':
-      align = align::center;
+    case ' ':
+      handler.on_space();
+      ++begin;
       break;
     }
-    if (align != align::none) {
-      if (i > 0) {
-        auto c = *begin;
-        if (c == '{')
-          return handler.on_error("invalid fill character '{'"), begin;
-        begin += 2;
-        handler.on_fill(c);
-      } else
-        ++begin;
-      handler.on_align(align);
-      break;
-    }
-  } while (i-- > 0);
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    handler.on_width(parse_nonnegative_int(begin, end, handler));
-  } else if (*begin == '{') {
-    ++begin;
-    if (begin != end)
-      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
-    if (begin == end || *begin != '}')
-      return handler.on_error("invalid format string"), begin;
-    ++begin;
-  }
-  return begin;
-}
+    if (begin == end)
+      return begin;
 
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
-                                          Handler&& handler) {
-  ++begin;
-  auto c = begin != end ? *begin : Char();
-  if ('0' <= c && c <= '9') {
-    handler.on_precision(parse_nonnegative_int(begin, end, handler));
-  } else if (c == '{') {
-    ++begin;
-    if (begin != end) {
-      begin =
-          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
+    if (*begin == '#') {
+      handler.on_hash();
+      if (++begin == end)
+        return begin;
     }
-    if (begin == end || *begin++ != '}')
-      return handler.on_error("invalid format string"), begin;
-  } else {
-    return handler.on_error("missing precision specifier"), begin;
-  }
-  handler.end_precision();
-  return begin;
-}
 
-// Parses standard format specifiers and sends notifications about parsed
-// components to handler.
-template <typename Char, typename SpecHandler>
-FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
-                                             SpecHandler&& handler) {
-  if (begin == end || *begin == '}') return begin;
-
-  begin = parse_align(begin, end, handler);
-  if (begin == end) return begin;
+    // Parse zero flag.
+    if (*begin == '0') {
+      handler.on_zero();
+      if (++begin == end)
+        return begin;
+    }
 
-  // Parse sign.
-  switch (static_cast<char>(*begin)) {
-  case '+':
-    handler.on_plus();
-    ++begin;
-    break;
-  case '-':
-    handler.on_minus();
-    ++begin;
-    break;
-  case ' ':
-    handler.on_space();
-    ++begin;
-    break;
-  }
-  if (begin == end) return begin;
+    begin = parse_width(begin, end, handler);
+    if (begin == end)
+      return begin;
 
-  if (*begin == '#') {
-    handler.on_hash();
-    if (++begin == end) return begin;
-  }
+    // Parse precision.
+    if (*begin == '.') {
+      begin = parse_precision(begin, end, handler);
+    }
 
-  // Parse zero flag.
-  if (*begin == '0') {
-    handler.on_zero();
-    if (++begin == end) return begin;
+    // Parse type.
+    if (begin != end && *begin != '}')
+      handler.on_type(*begin++);
+    return begin;
   }
 
-  begin = parse_width(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse precision.
-  if (*begin == '.') {
-    begin = parse_precision(begin, end, handler);
+  // Return the result via the out param to workaround gcc bug 77539.
+  template <bool IS_CONSTEXPR, typename T, typename Ptr = const T *>
+  FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
+  {
+    for (out = first; out != last; ++out) {
+      if (*out == value)
+        return true;
+    }
+    return false;
   }
 
-  // Parse type.
-  if (begin != end && *begin != '}') handler.on_type(*begin++);
-  return begin;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
+  template <>
+  inline bool find<false, char>(const char *first, const char *last, char value, const char *&out)
+  {
+    out = static_cast<const char *>(std::memchr(first, value, internal::to_unsigned(last - first)));
+    return out != nullptr;
   }
-  return false;
-}
 
-template <>
-inline bool find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) {
-  out = static_cast<const char*>(
-      std::memchr(first, value, internal::to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-template <typename Handler, typename Char> struct id_adapter {
-  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_arg_id(id);
-  }
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-  Handler& handler;
-};
+  template <typename Handler, typename Char> struct id_adapter
+  {
+    FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) { handler.on_arg_id(id); }
+    FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
+    Handler &          handler;
+  };
 
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
-                                       Handler&& handler) {
-  struct pfs_writer {
-    FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
-      if (begin == end) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(begin, end, '}', p))
-          return handler_.on_text(begin, end);
-        ++p;
-        if (p == end || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(begin, p);
-        begin = p + 1;
+  template <bool IS_CONSTEXPR, typename Char, typename Handler>
+  FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str, Handler &&handler)
+  {
+    struct pfs_writer
+    {
+      FMT_CONSTEXPR void operator()(const Char *begin, const Char *end)
+      {
+        if (begin == end)
+          return;
+        for (;;) {
+          const Char *p = nullptr;
+          if (!find<IS_CONSTEXPR>(begin, end, '}', p))
+            return handler_.on_text(begin, end);
+          ++p;
+          if (p == end || *p != '}')
+            return handler_.on_error("unmatched '}' in format string");
+          handler_.on_text(begin, p);
+          begin = p + 1;
+        }
       }
-    }
-    Handler& handler_;
-  } write{handler};
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
-      return write(begin, end);
-    write(begin, p);
-    ++p;
-    if (p == end) return handler.on_error("invalid format string");
-    if (static_cast<char>(*p) == '}') {
-      handler.on_arg_id();
-      handler.on_replacement_field(p);
-    } else if (*p == '{') {
-      handler.on_text(p, p + 1);
-    } else {
-      p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
-      Char c = p != end ? *p : Char();
-      if (c == '}') {
+      Handler &handler_;
+    } write{handler};
+    auto begin = format_str.data();
+    auto end   = begin + format_str.size();
+    while (begin != end) {
+      // Doing two passes with memchr (one for '{' and another for '}') is up to
+      // 2.5x faster than the naive one-pass implementation on big format strings.
+      const Char *p = begin;
+      if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
+        return write(begin, end);
+      write(begin, p);
+      ++p;
+      if (p == end)
+        return handler.on_error("invalid format string");
+      if (static_cast<char>(*p) == '}') {
+        handler.on_arg_id();
         handler.on_replacement_field(p);
-      } else if (c == ':') {
-        p = handler.on_format_specs(p + 1, end);
-        if (p == end || *p != '}')
-          return handler.on_error("unknown format specifier");
-      } else {
-        return handler.on_error("missing '}' in format string");
       }
+      else if (*p == '{') {
+        handler.on_text(p, p + 1);
+      }
+      else {
+        p      = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
+        Char c = p != end ? *p : Char();
+        if (c == '}') {
+          handler.on_replacement_field(p);
+        }
+        else if (c == ':') {
+          p = handler.on_format_specs(p + 1, end);
+          if (p == end || *p != '}')
+            return handler.on_error("unknown format specifier");
+        }
+        else {
+          return handler.on_error("missing '}' in format string");
+        }
+      }
+      begin = p + 1;
     }
-    begin = p + 1;
   }
-}
-
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
-    ParseContext& ctx) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type =
-      conditional_t<internal::mapped_type_constant<T, context>::value !=
-                        internal::custom_type,
-                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
-  conditional_t<has_formatter<mapped_type, context>::value,
-                formatter<mapped_type, char_type>,
-                internal::fallback_formatter<T, char_type>>
-      f;
-  return f.parse(ctx);
-}
 
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
-  explicit FMT_CONSTEXPR format_string_checker(
-      basic_string_view<Char> format_str, ErrorHandler eh)
-      : arg_id_((std::numeric_limits<unsigned>::max)()),
-        context_(format_str, eh),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+  template <typename T, typename ParseContext>
+  FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx)
+  {
+    using char_type = typename ParseContext::char_type;
+    using context   = buffer_context<char_type>;
+    using mapped_type =
+        conditional_t<internal::mapped_type_constant<T, context>::value != internal::custom_type,
+                      decltype(arg_mapper<context>().map(std::declval<T>())), T>;
+    auto f =
+        conditional_t<has_formatter<mapped_type, context>::value, formatter<mapped_type, char_type>,
+                      internal::fallback_formatter<T, char_type>>();
+    return f.parse(ctx);
+  }
+
+  template <typename Char, typename ErrorHandler, typename... Args> class format_string_checker
+  {
+  public:
+    explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> format_str,
+                                                 ErrorHandler            eh)
+        : arg_id_(max_value<unsigned>()),
+          context_(format_str, eh), parse_funcs_{&parse_format_specs<Args, parse_context_type>...}
+    {
+    }
 
-  FMT_CONSTEXPR void on_arg_id() {
-    arg_id_ = context_.next_arg_id();
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(int id) {
-    arg_id_ = id;
-    context_.check_arg_id(id);
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
-    on_error("compile-time checks don't support named arguments");
-  }
+    FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
 
-  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
+    FMT_CONSTEXPR void on_arg_id()
+    {
+      arg_id_ = context_.next_arg_id();
+      check_arg_id();
+    }
+    FMT_CONSTEXPR void on_arg_id(int id)
+    {
+      arg_id_ = id;
+      context_.check_arg_id(id);
+      check_arg_id();
+    }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>)
+    {
+      on_error("compile-time checks don't support named arguments");
+    }
 
-  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
-    advance_to(context_, begin);
-    return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
-  }
+    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
+    FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *)
+    {
+      advance_to(context_, begin);
+      return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
+    }
 
- private:
-  using parse_context_type = basic_parse_context<Char, ErrorHandler>;
-  enum { num_args = sizeof...(Args) };
+    FMT_CONSTEXPR void on_error(const char *message) { context_.on_error(message); }
 
-  FMT_CONSTEXPR void check_arg_id() {
-    if (arg_id_ >= num_args) context_.on_error("argument index out of range");
-  }
+  private:
+    using parse_context_type = basic_parse_context<Char, ErrorHandler>;
+    enum { num_args = sizeof...(Args) };
 
-  // Format specifier parsing function.
-  using parse_func = const Char* (*)(parse_context_type&);
+    FMT_CONSTEXPR void check_arg_id()
+    {
+      if (arg_id_ >= num_args)
+        context_.on_error("argument index out of range");
+    }
 
-  unsigned arg_id_;
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
-};
+    // Format specifier parsing function.
+    using parse_func = const Char *(*)(parse_context_type &);
 
-template <typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
-                                          ErrorHandler eh = ErrorHandler()) {
-  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
-  parse_format_string<true>(s, checker);
-  return true;
-}
+    unsigned           arg_id_;
+    parse_context_type context_;
+    parse_func         parse_funcs_[num_args > 0 ? num_args : 1];
+  };
 
-template <typename... Args, typename S,
-          enable_if_t<(is_compile_string<S>::value), int>>
-void check_format_string(S format_str) {
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      internal::do_check_format_string<typename S::char_type,
-                                       internal::error_handler, Args...>(
-          to_string_view(format_str));
-  (void)invalid_format;
-}
+  template <typename Char, typename ErrorHandler, typename... Args>
+  FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
+                                            ErrorHandler            eh = ErrorHandler())
+  {
+    format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
+    parse_format_string<true>(s, checker);
+    return true;
+  }
 
-template <template <typename> class Handler, typename Spec, typename Context>
-void handle_dynamic_spec(Spec& value, arg_ref<typename Context::char_type> ref,
-                         Context& ctx,
-                         const typename Context::char_type* format_str) {
-  switch (ref.kind) {
-  case arg_id_kind::none:
-    break;
-  case arg_id_kind::index:
-    internal::set_dynamic_spec<Handler>(value, ctx.arg(ref.val.index),
-                                        ctx.error_handler());
-    break;
-  case arg_id_kind::name: {
-    const auto arg_id = ref.val.name.to_view(format_str);
-    internal::set_dynamic_spec<Handler>(value, ctx.arg(arg_id),
-                                        ctx.error_handler());
-    break;
+  template <typename... Args, typename S, enable_if_t<(is_compile_string<S>::value), int>>
+  void check_format_string(S format_str)
+  {
+    FMT_CONSTEXPR_DECL bool invalid_format =
+        internal::do_check_format_string<typename S::char_type, internal::error_handler, Args...>(
+            to_string_view(format_str));
+    (void)invalid_format;
   }
+
+  template <template <typename> class Handler, typename Context>
+  void handle_dynamic_spec(int &value, arg_ref<typename Context::char_type> ref, Context &ctx)
+  {
+    switch (ref.kind) {
+    case arg_id_kind::none: break;
+    case arg_id_kind::index:
+      value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index), ctx.error_handler());
+      break;
+    case arg_id_kind::name:
+      value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name), ctx.error_handler());
+      break;
+    }
   }
-}
-}  // namespace internal
+} // namespace internal
 
-template <typename Range>
-using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
-using writer FMT_DEPRECATED_ALIAS = internal::writer;
-using wwriter FMT_DEPRECATED_ALIAS =
-    internal::basic_writer<internal::buffer_range<wchar_t>>;
+template <typename Range> using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
+using writer                                 FMT_DEPRECATED_ALIAS = internal::writer;
+using wwriter FMT_DEPRECATED_ALIAS = internal::basic_writer<buffer_range<wchar_t>>;
 
 /** The default argument formatter. */
-template <typename Range>
-class arg_formatter : public internal::arg_formatter_base<Range> {
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
+template <typename Range> class arg_formatter : public internal::arg_formatter_base<Range>
+{
+private:
+  using char_type    = typename Range::value_type;
+  using base         = internal::arg_formatter_base<Range>;
   using context_type = basic_format_context<typename base::iterator, char_type>;
 
-  context_type& ctx_;
-  basic_parse_context<char_type>* parse_ctx_;
+  context_type &                  ctx_;
+  basic_parse_context<char_type> *parse_ctx_;
 
- public:
-  using range = Range;
-  using iterator = typename base::iterator;
+public:
+  using range        = Range;
+  using iterator     = typename base::iterator;
   using format_specs = typename base::format_specs;
 
   /**
@@ -2623,19 +2799,19 @@ class arg_formatter : public internal::arg_formatter_base<Range> {
     *specs* contains format specifier information for standard argument types.
     \endrst
    */
-  explicit arg_formatter(context_type& ctx,
-                         basic_parse_context<char_type>* parse_ctx = nullptr,
-                         format_specs* f_specs = nullptr)
-      : base(Range(ctx.out()), f_specs, ctx.locale()),
-        ctx_(ctx),
-        parse_ctx_(parse_ctx) {}
+  explicit arg_formatter(context_type &ctx, basic_parse_context<char_type> *parse_ctx = nullptr,
+                         format_specs *specs = nullptr)
+      : base(Range(ctx.out()), specs, ctx.locale()), ctx_(ctx), parse_ctx_(parse_ctx)
+  {
+  }
 
   using base::operator();
 
   /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+  iterator operator()(typename basic_format_arg<context_type>::handle handle)
+  {
     handle.format(*parse_ctx_, ctx_);
-    return this->out();
+    return ctx_.out();
   }
 };
 
@@ -2643,16 +2819,17 @@ class arg_formatter : public internal::arg_formatter_base<Range> {
  An error returned by an operating system or a language runtime,
  for example a file opening error.
 */
-class FMT_API system_error : public std::runtime_error {
- private:
+class FMT_API system_error : public std::runtime_error
+{
+private:
   void init(int err_code, string_view format_str, format_args args);
 
- protected:
+protected:
   int error_code_;
 
   system_error() : std::runtime_error(""), error_code_(0) {}
 
- public:
+public:
   /**
    \rst
    Constructs a :class:`fmt::system_error` object with a description
@@ -2672,10 +2849,14 @@ class FMT_API system_error : public std::runtime_error {
    \endrst
   */
   template <typename... Args>
-  system_error(int p_error_code, string_view message, const Args&... args)
-      : std::runtime_error("") {
-    init(p_error_code, message, make_format_args(args...));
+  system_error(int error_code, string_view message, const Args &... args) : std::runtime_error("")
+  {
+    init(error_code, message, make_format_args(args...));
   }
+  system_error(const system_error &) = default;
+  system_error &operator=(const system_error &) = default;
+  system_error(system_error &&)                 = default;
+  system_error &operator=(system_error &&) = default;
   ~system_error() FMT_NOEXCEPT;
 
   int error_code() const { return error_code_; }
@@ -2697,10 +2878,11 @@ class FMT_API system_error : public std::runtime_error {
   may look like "Unknown error -1" and is platform-dependent.
   \endrst
  */
-FMT_API void format_system_error(internal::buffer<char>& out, int error_code,
+FMT_API void format_system_error(internal::buffer<char> &out, int error_code,
                                  fmt::string_view message) FMT_NOEXCEPT;
 
-struct float_spec_handler {
+struct float_spec_handler
+{
   char type;
   bool upper;
   bool fixed;
@@ -2708,130 +2890,137 @@ struct float_spec_handler {
   bool use_locale;
 
   explicit float_spec_handler(char t)
-      : type(t),
-        upper(false),
-        fixed(false),
-        as_percentage(false),
-        use_locale(false) {}
+      : type(t), upper(false), fixed(false), as_percentage(false), use_locale(false)
+  {
+  }
 
-  void on_general() {
-    if (type == 'G') upper = true;
+  void on_general()
+  {
+    if (type == 'G')
+      upper = true;
   }
 
-  void on_exp() {
-    if (type == 'E') upper = true;
+  void on_exp()
+  {
+    if (type == 'E')
+      upper = true;
   }
 
-  void on_fixed() {
+  void on_fixed()
+  {
     fixed = true;
-    if (type == 'F') upper = true;
+    if (type == 'F')
+      upper = true;
   }
 
-  void on_percent() {
-    fixed = true;
+  void on_percent()
+  {
+    fixed         = true;
     as_percentage = true;
   }
 
-  void on_hex() {
-    if (type == 'A') upper = true;
+  void on_hex()
+  {
+    if (type == 'A')
+      upper = true;
   }
 
   void on_num() { use_locale = true; }
 
-  FMT_NORETURN void on_error() {
-    FMT_THROW(format_error("invalid type specifier"));
-  }
+  FMT_NORETURN void on_error() { FMT_THROW(format_error("invalid type specifier")); }
 };
 
 template <typename Range>
 template <typename T, bool USE_GRISU>
-void internal::basic_writer<Range>::write_double(T value,
-                                                 const format_specs& specs) {
+void internal::basic_writer<Range>::write_fp(T value, const format_specs &specs)
+{
   // Check type.
   float_spec_handler handler(static_cast<char>(specs.type));
-  internal::handle_float_type_spec(handler.type, handler);
+  handle_float_type_spec(handler.type, handler);
 
-  char sign = 0;
+  auto sign = specs.sign;
   // Use signbit instead of value < 0 since the latter is always false for NaN.
   if (std::signbit(value)) {
-    sign = '-';
+    sign  = sign::minus;
     value = -value;
-  } else if (specs.sign != sign::none) {
-    if (specs.sign == sign::plus)
-      sign = '+';
-    else if (specs.sign == sign::space)
-      sign = ' ';
+  }
+  else if (sign == sign::minus) {
+    sign = sign::none;
   }
 
   if (!std::isfinite(value)) {
-    // Format infinity and NaN ourselves because sprintf's output is not
-    // consistent across platforms.
-    const char* str = std::isinf(value) ? (handler.upper ? "INF" : "inf")
-                                        : (handler.upper ? "NAN" : "nan");
-    return write_padded(specs,
-                        inf_or_nan_writer{sign, handler.as_percentage, str});
+    const char *str =
+        std::isinf(value) ? (handler.upper ? "INF" : "inf") : (handler.upper ? "NAN" : "nan");
+    return write_padded(specs, inf_or_nan_writer{sign, handler.as_percentage, str});
   }
 
-  if (handler.as_percentage) value *= 100;
+  if (handler.as_percentage)
+    value *= 100;
 
   memory_buffer buffer;
-  int exp = 0;
-  int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
-  unsigned options = handler.fixed ? internal::grisu_options::fixed : 0;
-  bool use_grisu = USE_GRISU &&
-                   (specs.type != 'a' && specs.type != 'A' &&
-                    specs.type != 'e' && specs.type != 'E') &&
-                   internal::grisu_format(static_cast<double>(value), buffer,
-                                          precision, options, exp);
-  char* decimal_point_pos = nullptr;
+  int           exp       = 0;
+  int           precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
+  unsigned      options   = 0;
+  if (handler.fixed)
+    options |= grisu_options::fixed;
+  if (const_check(sizeof(value) == sizeof(float)))
+    options |= grisu_options::binary32;
+  bool use_grisu =
+      USE_GRISU &&
+      (specs.type != 'a' && specs.type != 'A' && specs.type != 'e' && specs.type != 'E') &&
+      grisu_format(static_cast<double>(value), buffer, precision, options, exp);
+  char *decimal_point_pos = nullptr;
   if (!use_grisu)
-    decimal_point_pos = internal::sprintf_format(value, buffer, specs);
+    decimal_point_pos = sprintf_format(value, buffer, specs);
 
   if (handler.as_percentage) {
     buffer.push_back('%');
-    --exp;  // Adjust decimal place position.
+    --exp; // Adjust decimal place position.
   }
   format_specs as = specs;
   if (specs.align == align::numeric) {
     if (sign) {
-      auto&& it = reserve(1);
-      *it++ = static_cast<char_type>(sign);
-      sign = 0;
-      if (as.width) --as.width;
+      auto &&it = reserve(1);
+      *it++     = static_cast<char_type>(data::signs[sign]);
+      sign      = sign::none;
+      if (as.width)
+        --as.width;
     }
     as.align = align::right;
-  } else if (specs.align == align::none) {
+  }
+  else if (specs.align == align::none) {
     as.align = align::right;
   }
-  char_type decimal_point = handler.use_locale
-                                ? internal::decimal_point<char_type>(locale_)
-                                : static_cast<char_type>('.');
+  char_type decimal_point = handler.use_locale ? internal::decimal_point<char_type>(locale_)
+                                               : static_cast<char_type>('.');
   if (use_grisu) {
-    auto params = internal::gen_digits_params();
-    params.fixed = handler.fixed;
-    params.num_digits = precision;
-    params.trailing_zeros =
-        (precision != 0 && (handler.fixed || !specs.type)) || specs.alt;
-    write_padded(as, grisu_writer(sign, buffer, exp, params, decimal_point));
-  } else {
+    auto params           = gen_digits_params();
+    params.sign           = sign;
+    params.fixed          = handler.fixed;
+    params.num_digits     = precision;
+    params.trailing_zeros = (precision != 0 && (handler.fixed || !specs.type)) || specs.alt;
+    int num_digits        = static_cast<int>(buffer.size());
     write_padded(as,
-                 double_writer{sign, buffer, decimal_point_pos, decimal_point});
+                 grisu_writer<char_type>(buffer.data(), num_digits, exp, params, decimal_point));
+  }
+  else {
+    write_padded(as, double_writer{sign, buffer, decimal_point_pos, decimal_point});
   }
 }
 
 // Reports a system error without throwing an exception.
 // Can be used to report errors from destructors.
-FMT_API void report_system_error(int error_code,
-                                 string_view message) FMT_NOEXCEPT;
+FMT_API void report_system_error(int error_code, string_view message) FMT_NOEXCEPT;
 
 #if FMT_USE_WINDOWS_H
 
 /** A Windows error. */
-class windows_error : public system_error {
- private:
+class windows_error : public system_error
+{
+private:
   FMT_API void init(int error_code, string_view format_str, format_args args);
 
- public:
+public:
   /**
    \rst
    Constructs a :class:`fmt::windows_error` object with the description
@@ -2861,30 +3050,32 @@ class windows_error : public system_error {
    \endrst
   */
   template <typename... Args>
-  windows_error(int error_code, string_view message, const Args&... args) {
+  windows_error(int error_code, string_view message, const Args &... args)
+  {
     init(error_code, message, make_format_args(args...));
   }
 };
 
 // Reports a Windows error without throwing an exception.
 // Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code,
-                                  string_view message) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code, string_view message) FMT_NOEXCEPT;
 
 #endif
 
 /** Fast integer formatter. */
-class format_int {
- private:
+class format_int
+{
+private:
   // Buffer should be large enough to hold all digits (digits10 + 1),
   // a sign and a null character.
   enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
   mutable char buffer_[buffer_size];
-  char* str_;
+  char *       str_;
 
   // Formats value in reverse and returns a pointer to the beginning.
-  char* format_decimal(unsigned long long value) {
-    char* ptr = buffer_ + (buffer_size - 1);  // Parens to workaround MSVC bug.
+  char *format_decimal(unsigned long long value)
+  {
+    char *ptr = buffer_ + (buffer_size - 1); // Parens to workaround MSVC bug.
     while (value >= 100) {
       // Integer division is slow so do it for a group of two digits instead
       // of for every digit. The idea comes from the talk by Alexandrescu
@@ -2899,20 +3090,23 @@ class format_int {
       return ptr;
     }
     unsigned index = static_cast<unsigned>(value * 2);
-    *--ptr = internal::data::digits[index + 1];
-    *--ptr = internal::data::digits[index];
+    *--ptr         = internal::data::digits[index + 1];
+    *--ptr         = internal::data::digits[index];
     return ptr;
   }
 
-  void format_signed(long long value) {
+  void format_signed(long long value)
+  {
     unsigned long long abs_value = static_cast<unsigned long long>(value);
-    bool negative = value < 0;
-    if (negative) abs_value = 0 - abs_value;
+    bool               negative  = value < 0;
+    if (negative)
+      abs_value = 0 - abs_value;
     str_ = format_decimal(abs_value);
-    if (negative) *--str_ = '-';
+    if (negative)
+      *--str_ = '-';
   }
 
- public:
+public:
   explicit format_int(int value) { format_signed(value); }
   explicit format_int(long value) { format_signed(value); }
   explicit format_int(long long value) { format_signed(value); }
@@ -2921,21 +3115,20 @@ class format_int {
   explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
 
   /** Returns the number of characters written to the output buffer. */
-  std::size_t size() const {
-    return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
-  }
+  std::size_t size() const { return internal::to_unsigned(buffer_ - str_ + buffer_size - 1); }
 
   /**
     Returns a pointer to the output buffer content. No terminating null
     character is appended.
    */
-  const char* data() const { return str_; }
+  const char *data() const { return str_; }
 
   /**
     Returns a pointer to the output buffer content with terminating null
     character appended.
    */
-  const char* c_str() const {
+  const char *c_str() const
+  {
     buffer_[buffer_size - 1] = '\0';
     return str_;
   }
@@ -2952,53 +3145,46 @@ class format_int {
 // constants.
 template <typename T, typename Char>
 struct formatter<T, Char,
-                 enable_if_t<internal::type_constant<T, Char>::value !=
-                             internal::custom_type>> {
-  FMT_CONSTEXPR formatter() : format_str_(nullptr) {}
+                 enable_if_t<internal::type_constant<T, Char>::value != internal::custom_type>>
+{
+  FMT_CONSTEXPR formatter() {}
 
   // Parses format specifiers stopping either at the end of the range or at the
   // terminating '}'.
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    format_str_ = ctx.begin();
-    using handler_type = internal::dynamic_specs_handler<ParseContext>;
-    auto type = internal::type_constant<T, Char>::value;
-    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
-                                                  type);
-    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
-    auto eh = ctx.error_handler();
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
+    using handler_type                         = internal::dynamic_specs_handler<ParseContext>;
+    auto                                  type = internal::type_constant<T, Char>::value;
+    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx), type);
+    auto                                  it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    auto                                  eh = ctx.error_handler();
     switch (type) {
     case internal::none_type:
-    case internal::named_arg_type:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
+    case internal::named_arg_type: FMT_ASSERT(false, "invalid argument type"); break;
     case internal::int_type:
     case internal::uint_type:
     case internal::long_long_type:
     case internal::ulong_long_type:
+    case internal::int128_type:
+    case internal::uint128_type:
     case internal::bool_type:
-      handle_int_type_spec(specs_.type,
-                           internal::int_type_checker<decltype(eh)>(eh));
+      handle_int_type_spec(specs_.type, internal::int_type_checker<decltype(eh)>(eh));
       break;
     case internal::char_type:
-      handle_char_specs(
-          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
+      handle_char_specs(&specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
       break;
+    case internal::float_type:
     case internal::double_type:
     case internal::long_double_type:
-      handle_float_type_spec(specs_.type,
-                             internal::float_type_checker<decltype(eh)>(eh));
+      handle_float_type_spec(specs_.type, internal::float_type_checker<decltype(eh)>(eh));
       break;
     case internal::cstring_type:
-      internal::handle_cstring_type_spec(
-          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::string_type:
-      internal::check_string_type_spec(specs_.type, eh);
-      break;
-    case internal::pointer_type:
-      internal::check_pointer_type_spec(specs_.type, eh);
+      internal::handle_cstring_type_spec(specs_.type,
+                                         internal::cstring_type_checker<decltype(eh)>(eh));
       break;
+    case internal::string_type: internal::check_string_type_spec(specs_.type, eh); break;
+    case internal::pointer_type: internal::check_pointer_type_spec(specs_.type, eh); break;
     case internal::custom_type:
       // Custom format specifiers should be checked in parse functions of
       // formatter specializations.
@@ -3008,30 +3194,29 @@ struct formatter<T, Char,
   }
 
   template <typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx, format_str_);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx, format_str_);
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+  {
+    internal::handle_dynamic_spec<internal::width_checker>(specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision,
+                                                               specs_.precision_ref, ctx);
     using range_type =
-        internal::output_range<typename FormatContext::iterator,
-                               typename FormatContext::char_type>;
+        internal::output_range<typename FormatContext::iterator, typename FormatContext::char_type>;
     return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
                             internal::make_arg<FormatContext>(val));
   }
 
- private:
+private:
   internal::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
 };
 
-#define FMT_FORMAT_AS(Type, Base)                                             \
-  template <typename Char>                                                    \
-  struct formatter<Type, Char> : formatter<Base, Char> {                      \
-    template <typename FormatContext>                                         \
-    auto format(const Type& val, FormatContext& ctx) -> decltype(ctx.out()) { \
-      return formatter<Base, Char>::format(val, ctx);                         \
-    }                                                                         \
+#define FMT_FORMAT_AS(Type, Base)                                                                  \
+  template <typename Char> struct formatter<Type, Char> : formatter<Base, Char>                    \
+  {                                                                                                \
+    template <typename FormatContext>                                                              \
+    auto format(const Type &val, FormatContext &ctx) -> decltype(ctx.out())                        \
+    {                                                                                              \
+      return formatter<Base, Char>::format(val, ctx);                                              \
+    }                                                                                              \
   }
 
 FMT_FORMAT_AS(signed char, int);
@@ -3040,24 +3225,26 @@ FMT_FORMAT_AS(short, int);
 FMT_FORMAT_AS(unsigned short, unsigned);
 FMT_FORMAT_AS(long, long long);
 FMT_FORMAT_AS(unsigned long, unsigned long long);
-FMT_FORMAT_AS(float, double);
-FMT_FORMAT_AS(Char*, const Char*);
+FMT_FORMAT_AS(Char *, const Char *);
 FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
-FMT_FORMAT_AS(std::nullptr_t, const void*);
+FMT_FORMAT_AS(std::nullptr_t, const void *);
 FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);
 
-template <typename Char>
-struct formatter<void*, Char> : formatter<const void*, Char> {
+template <typename Char> struct formatter<void *, Char> : formatter<const void *, Char>
+{
   template <typename FormatContext>
-  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
-    return formatter<const void*, Char>::format(val, ctx);
+  auto format(void *val, FormatContext &ctx) -> decltype(ctx.out())
+  {
+    return formatter<const void *, Char>::format(val, ctx);
   }
 };
 
 template <typename Char, size_t N>
-struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char>
+{
   template <typename FormatContext>
-  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const Char *val, FormatContext &ctx) -> decltype(ctx.out())
+  {
     return formatter<basic_string_view<Char>, Char>::format(val, ctx);
   }
 };
@@ -3072,9 +3259,11 @@ struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
 //       visit([&](const auto &val) { format(buf, val, ctx); }, v);
 //     }
 //   };
-template <typename Char = char> class dynamic_formatter {
- private:
-  struct null_handler : internal::error_handler {
+template <typename Char = char> class dynamic_formatter
+{
+private:
+  struct null_handler : internal::error_handler
+  {
     void on_align(align_t) {}
     void on_plus() {}
     void on_minus() {}
@@ -3082,9 +3271,9 @@ template <typename Char = char> class dynamic_formatter {
     void on_hash() {}
   };
 
- public:
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+public:
+  template <typename ParseContext> auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     format_str_ = ctx.begin();
     // Checks are deferred to formatting time when the argument type is known.
     internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
@@ -3092,124 +3281,124 @@ template <typename Char = char> class dynamic_formatter {
   }
 
   template <typename T, typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+  {
     handle_specs(ctx);
     internal::specs_checker<null_handler> checker(
-        null_handler(),
-        internal::mapped_type_constant<T, FormatContext>::value);
+        null_handler(), internal::mapped_type_constant<T, FormatContext>::value);
     checker.on_align(specs_.align);
     switch (specs_.sign) {
-    case sign::none:
-      break;
-    case sign::plus:
-      checker.on_plus();
-      break;
-    case sign::minus:
-      checker.on_minus();
-      break;
-    case sign::space:
-      checker.on_space();
-      break;
+    case sign::none: break;
+    case sign::plus: checker.on_plus(); break;
+    case sign::minus: checker.on_minus(); break;
+    case sign::space: checker.on_space(); break;
     }
-    if (specs_.alt) checker.on_hash();
-    if (specs_.precision >= 0) checker.end_precision();
-    using range = internal::output_range<typename FormatContext::iterator,
-                                         typename FormatContext::char_type>;
+    if (specs_.alt)
+      checker.on_hash();
+    if (specs_.precision >= 0)
+      checker.end_precision();
+    using range =
+        internal::output_range<typename FormatContext::iterator, typename FormatContext::char_type>;
     visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
                      internal::make_arg<FormatContext>(val));
     return ctx.out();
   }
 
- private:
-  template <typename Context> void handle_specs(Context& ctx) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx, format_str_);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx, format_str_);
+private:
+  template <typename Context> void handle_specs(Context &ctx)
+  {
+    internal::handle_dynamic_spec<internal::width_checker>(specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision,
+                                                               specs_.precision_ref, ctx);
   }
 
   internal::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
+  const Char *                         format_str_;
 };
 
 template <typename Range, typename Char>
 typename basic_format_context<Range, Char>::format_arg
-basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
+basic_format_context<Range, Char>::arg(basic_string_view<char_type> name)
+{
   map_.init(args_);
-  format_arg f_arg = map_.find(name);
-  if (f_arg.type() == internal::none_type) this->on_error("argument not found");
-  return f_arg;
+  format_arg arg = map_.find(name);
+  if (arg.type() == internal::none_type)
+    this->on_error("argument not found");
+  return arg;
 }
 
 template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void advance_to(basic_parse_context<Char, ErrorHandler>& ctx,
-                              const Char* p) {
+FMT_CONSTEXPR void advance_to(basic_parse_context<Char, ErrorHandler> &ctx, const Char *p)
+{
   ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
 }
 
 template <typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler {
+struct format_handler : internal::error_handler
+{
   using range = typename ArgFormatter::range;
 
-  format_handler(range r, basic_string_view<Char> str,
-                 basic_format_args<Context> format_args,
+  format_handler(range r, basic_string_view<Char> str, basic_format_args<Context> format_args,
                  internal::locale_ref loc)
-      : parse_context(str), context(r.begin(), format_args, loc) {}
+      : parse_context(str), context(r.begin(), format_args, loc)
+  {
+  }
 
-  void on_text(const Char* begin, const Char* end) {
-    auto size = internal::to_unsigned(end - begin);
-    auto out = context.out();
-    auto&& it = internal::reserve(out, size);
-    it = std::copy_n(begin, size, it);
+  void on_text(const Char *begin, const Char *end)
+  {
+    auto   size = internal::to_unsigned(end - begin);
+    auto   out  = context.out();
+    auto &&it   = internal::reserve(out, size);
+    it          = std::copy_n(begin, size, it);
     context.advance_to(out);
   }
 
   void get_arg(int id) { arg = internal::get_arg(context, id); }
 
   void on_arg_id() { get_arg(parse_context.next_arg_id()); }
-  void on_arg_id(int id) {
+  void on_arg_id(int id)
+  {
     parse_context.check_arg_id(id);
     get_arg(id);
   }
   void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
 
-  void on_replacement_field(const Char* p) {
+  void on_replacement_field(const Char *p)
+  {
     advance_to(parse_context, p);
-    internal::custom_formatter<Context> f(parse_context, context);
-    if (!visit_format_arg(f, arg))
-      context.advance_to(
-          visit_format_arg(ArgFormatter(context, &parse_context), arg));
+    context.advance_to(visit_format_arg(ArgFormatter(context, &parse_context), arg));
   }
 
-  const Char* on_format_specs(const Char* begin, const Char* end) {
+  const Char *on_format_specs(const Char *begin, const Char *end)
+  {
     advance_to(parse_context, begin);
     internal::custom_formatter<Context> f(parse_context, context);
-    if (visit_format_arg(f, arg)) return parse_context.begin();
+    if (visit_format_arg(f, arg))
+      return parse_context.begin();
     basic_format_specs<Char> specs;
     using internal::specs_handler;
     using parse_context_t = basic_parse_context<Char>;
     internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
-        specs_handler<parse_context_t, Context>(specs, parse_context, context),
-        arg.type());
+        specs_handler<parse_context_t, Context>(specs, parse_context, context), arg.type());
     begin = parse_format_specs(begin, end, handler);
-    if (begin == end || *begin != '}') on_error("missing '}' in format string");
+    if (begin == end || *begin != '}')
+      on_error("missing '}' in format string");
     advance_to(parse_context, begin);
-    context.advance_to(
-        visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
+    context.advance_to(visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
     return begin;
   }
 
   basic_parse_context<Char> parse_context;
-  Context context;
+  Context                   context;
   basic_format_arg<Context> arg;
 };
 
 /** Formats arguments and writes the output to the range. */
 template <typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator vformat_to(
-    typename ArgFormatter::range out, basic_string_view<Char> format_str,
-    basic_format_args<Context> args,
-    internal::locale_ref loc = internal::locale_ref()) {
+typename Context::iterator
+vformat_to(typename ArgFormatter::range out, basic_string_view<Char> format_str,
+           basic_format_args<Context> args, internal::locale_ref loc = internal::locale_ref())
+{
   format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
   internal::parse_format_string<false>(format_str, h);
   return h.context.out();
@@ -3218,17 +3407,14 @@ typename Context::iterator vformat_to(
 // Casts ``p`` to ``const void*`` for pointer formatting.
 // Example:
 //   auto s = format("{}", ptr(p));
-template <typename T> inline const void* ptr(const T* p) { return p; }
-template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
-  return p.get();
-}
-template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
-  return p.get();
-}
-
-template <typename It, typename Char> struct arg_join : internal::view {
-  It begin;
-  It end;
+template <typename T> inline const void *ptr(const T *p) { return p; }
+template <typename T> inline const void *ptr(const std::unique_ptr<T> &p) { return p.get(); }
+template <typename T> inline const void *ptr(const std::shared_ptr<T> &p) { return p.get(); }
+
+template <typename It, typename Char> struct arg_join : internal::view
+{
+  It                      begin;
+  It                      end;
   basic_string_view<Char> sep;
 
   arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
@@ -3236,13 +3422,14 @@ template <typename It, typename Char> struct arg_join : internal::view {
 
 template <typename It, typename Char>
 struct formatter<arg_join<It, Char>, Char>
-    : formatter<typename std::iterator_traits<It>::value_type, Char> {
+    : formatter<typename std::iterator_traits<It>::value_type, Char>
+{
   template <typename FormatContext>
-  auto format(const arg_join<It, Char>& value, FormatContext& ctx)
-      -> decltype(ctx.out()) {
+  auto format(const arg_join<It, Char> &value, FormatContext &ctx) -> decltype(ctx.out())
+  {
     using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
-    auto it = value.begin;
-    auto out = ctx.out();
+    auto it    = value.begin;
+    auto out   = ctx.out();
     if (it != value.end) {
       out = base::format(*it++, ctx);
       while (it != value.end) {
@@ -3259,13 +3446,13 @@ struct formatter<arg_join<It, Char>, Char>
   Returns an object that formats the iterator range `[begin, end)` with elements
   separated by `sep`.
  */
-template <typename It>
-arg_join<It, char> join(It begin, It end, string_view sep) {
+template <typename It> arg_join<It, char> join(It begin, It end, string_view sep)
+{
   return {begin, end, sep};
 }
 
-template <typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
+template <typename It> arg_join<It, wchar_t> join(It begin, It end, wstring_view sep)
+{
   return {begin, end, sep};
 }
 
@@ -3281,14 +3468,14 @@ arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
   \endrst
  */
 template <typename Range>
-arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
-                                                       string_view sep) {
+arg_join<internal::iterator_t<const Range>, char> join(const Range &range, string_view sep)
+{
   return join(std::begin(range), std::end(range), sep);
 }
 
 template <typename Range>
-arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
-                                                          wstring_view sep) {
+arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range &range, wstring_view sep)
+{
   return join(std::begin(range), std::end(range), sep);
 }
 
@@ -3304,43 +3491,44 @@ arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
     std::string answer = fmt::to_string(42);
   \endrst
  */
-template <typename T> inline std::string to_string(const T& value) {
-  return format("{}", value);
-}
+template <typename T> inline std::string to_string(const T &value) { return format("{}", value); }
 
 /**
   Converts *value* to ``std::wstring`` using the default format for type *T*.
  */
-template <typename T> inline std::wstring to_wstring(const T& value) {
+template <typename T> inline std::wstring to_wstring(const T &value)
+{
   return format(L"{}", value);
 }
 
 template <typename Char, std::size_t SIZE>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
+std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE> &buf)
+{
   return std::basic_string<Char>(buf.data(), buf.size());
 }
 
 template <typename Char>
-typename buffer_context<Char>::iterator internal::vformat_to(
-    internal::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
+typename buffer_context<Char>::iterator
+internal::vformat_to(internal::buffer<Char> &buf, basic_string_view<Char> format_str,
+                     basic_format_args<buffer_context<Char>> args)
+{
   using range = buffer_range<Char>;
-  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
-                                          args);
+  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args);
 }
 
-template <typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline typename buffer_context<Char>::iterator vformat_to(
-    internal::buffer<Char>& buf, const S& format_str,
-    basic_format_args<buffer_context<Char>> args) {
+template <typename S, typename Char = char_t<S>, FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline typename buffer_context<Char>::iterator
+vformat_to(internal::buffer<Char> &buf, const S &format_str,
+           basic_format_args<buffer_context<Char>> args)
+{
   return internal::vformat_to(buf, to_string_view(format_str), args);
 }
 
 template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline typename buffer_context<Char>::iterator format_to(
-    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
+inline typename buffer_context<Char>::iterator format_to(basic_memory_buffer<Char, SIZE> &buf,
+                                                         const S &format_str, Args &&... args)
+{
   internal::check_format_string<Args...>(format_str);
   using context = buffer_context<Char>;
   return internal::vformat_to(buf, to_string_view(format_str),
@@ -3354,14 +3542,13 @@ template <typename OutputIt, typename Char = char>
 using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
 
 template <typename S, typename OutputIt, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
-inline OutputIt vformat_to(OutputIt out, const S& format_str,
-                           format_args_t<OutputIt, char_t<S>> args) {
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value &&
+                        !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
+inline OutputIt vformat_to(OutputIt out, const S &format_str,
+                           format_args_t<OutputIt, char_t<S>> args)
+{
   using range = internal::output_range<OutputIt, char_t<S>>;
-  return vformat_to<arg_formatter<range>>(range(out),
-                                          to_string_view(format_str), args);
+  return vformat_to<arg_formatter<range>>(range(out), to_string_view(format_str), args);
 }
 
 /**
@@ -3376,18 +3563,18 @@ inline OutputIt vformat_to(OutputIt out, const S& format_str,
  \endrst
  */
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
-              internal::is_string<S>::value)>
-inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value &&
+                        !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
+                        internal::is_string<S>::value)>
+inline OutputIt format_to(OutputIt out, const S &format_str, Args &&... args)
+{
   internal::check_format_string<Args...>(format_str);
   using context = format_context_t<OutputIt, char_t<S>>;
-  return vformat_to(out, to_string_view(format_str),
-                    {make_format_args<context>(args...)});
+  return vformat_to(out, to_string_view(format_str), {make_format_args<context>(args...)});
 }
 
-template <typename OutputIt> struct format_to_n_result {
+template <typename OutputIt> struct format_to_n_result
+{
   /** Iterator past the end of the output range. */
   OutputIt out;
   /** Total (not truncated) output size. */
@@ -3395,26 +3582,25 @@ template <typename OutputIt> struct format_to_n_result {
 };
 
 template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_context =
-    format_context_t<fmt::internal::truncating_iterator<OutputIt>, Char>;
+using format_to_n_context = format_context_t<fmt::internal::truncating_iterator<OutputIt>, Char>;
 
 template <typename OutputIt, typename Char = typename OutputIt::value_type>
 using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
 
 template <typename OutputIt, typename Char, typename... Args>
 inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
-make_format_to_n_args(const Args&... args) {
-  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
-      args...);
+make_format_to_n_args(const Args &... args)
+{
+  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(args...);
 }
 
 template <typename OutputIt, typename Char, typename... Args,
           FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> vformat_to_n(
-    OutputIt out, std::size_t n, basic_string_view<Char> format_str,
-    format_to_n_args<OutputIt, Char> args) {
-  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
-                       format_str, args);
+inline format_to_n_result<OutputIt> vformat_to_n(OutputIt out, std::size_t n,
+                                                 basic_string_view<Char>          format_str,
+                                                 format_to_n_args<OutputIt, Char> args)
+{
+  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n), format_str, args);
   return {it.base(), it.count()};
 }
 
@@ -3425,22 +3611,21 @@ inline format_to_n_result<OutputIt> vformat_to_n(
  end of the output range.
  \endrst
  */
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value&&
-                            internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
-                                                const S& format_str,
-                                                const Args&... args) {
+template <
+    typename OutputIt, typename S, typename... Args,
+    FMT_ENABLE_IF(internal::is_string<S>::value &&internal::is_output_iterator<OutputIt>::value)>
+inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n, const S &format_str,
+                                                const Args &... args)
+{
   internal::check_format_string<Args...>(format_str);
   using context = format_to_n_context<OutputIt, char_t<S>>;
-  return vformat_to_n(out, n, to_string_view(format_str),
-                      {make_format_args<context>(args...)});
+  return vformat_to_n(out, n, to_string_view(format_str), {make_format_args<context>(args...)});
 }
 
 template <typename Char>
-inline std::basic_string<Char> internal::vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
+inline std::basic_string<Char> internal::vformat(basic_string_view<Char>                 format_str,
+                                                 basic_format_args<buffer_context<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   return fmt::to_string(buffer);
@@ -3451,100 +3636,106 @@ inline std::basic_string<Char> internal::vformat(
   ``format(format_str, args...)``.
  */
 template <typename... Args>
-inline std::size_t formatted_size(string_view format_str, const Args&... args) {
-  auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
+inline std::size_t formatted_size(string_view format_str, const Args &... args)
+{
+  auto it = format_to(internal::counting_iterator(), format_str, args...);
   return it.count();
 }
 
 #if FMT_USE_USER_DEFINED_LITERALS
 namespace internal {
 
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS> class udl_formatter {
- public:
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-    FMT_CONSTEXPR_DECL bool invalid_format =
-        do_check_format_string<Char, error_handler, Args...>(
-            basic_string_view<Char>(s, sizeof...(CHARS)));
-    (void)invalid_format;
-    return format(s, std::forward<Args>(args)...);
-  }
-};
-#  else
-template <typename Char> struct udl_formatter {
-  basic_string_view<Char> str;
+#if FMT_USE_UDL_TEMPLATE
+  template <typename Char, Char... CHARS> class udl_formatter
+  {
+  public:
+    template <typename... Args> std::basic_string<Char> operator()(Args &&... args) const
+    {
+      FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
+      FMT_CONSTEXPR_DECL bool invalid_format =
+          do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
+              basic_string_view<Char>(s, sizeof...(CHARS)));
+      (void)invalid_format;
+      return format(s, std::forward<Args>(args)...);
+    }
+  };
+#else
+  template <typename Char> struct udl_formatter
+  {
+    basic_string_view<Char> str;
 
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    return format(str, std::forward<Args>(args)...);
-  }
-};
-#  endif  // FMT_USE_UDL_TEMPLATE
+    template <typename... Args> std::basic_string<Char> operator()(Args &&... args) const
+    {
+      return format(str, std::forward<Args>(args)...);
+    }
+  };
+#endif // FMT_USE_UDL_TEMPLATE
 
-template <typename Char> struct udl_arg {
-  basic_string_view<Char> str;
+  template <typename Char> struct udl_arg
+  {
+    basic_string_view<Char> str;
 
-  template <typename T> named_arg<T, Char> operator=(T&& value) const {
-    return {str, std::forward<T>(value)};
-  }
-};
+    template <typename T> named_arg<T, Char> operator=(T &&value) const
+    {
+      return {str, std::forward<T>(value)};
+    }
+  };
 
-}  // namespace internal
+} // namespace internal
 
 inline namespace literals {
-#  if FMT_USE_UDL_TEMPLATE
-#    pragma GCC diagnostic push
-#    if FMT_CLANG_VERSION
-#      pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
-#    endif
-template <typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
-  return {};
-}
-#    pragma GCC diagnostic pop
-#  else
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::format`.
+#if FMT_USE_UDL_TEMPLATE
+#pragma GCC diagnostic push
+#if FMT_CLANG_VERSION
+#pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
+#endif
+  template <typename Char, Char... CHARS>
+  FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format()
+  {
+    return {};
+  }
+#pragma GCC diagnostic pop
+#else
+  /**
+    \rst
+    User-defined literal equivalent of :func:`fmt::format`.
 
-  **Example**::
+    **Example**::
 
-    using namespace fmt::literals;
-    std::string message = "The answer is {}"_format(42);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
-                                                               std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
-    const wchar_t* s, std::size_t n) {
-  return {{s, n}};
-}
-#  endif  // FMT_USE_UDL_TEMPLATE
+      using namespace fmt::literals;
+      std::string message = "The answer is {}"_format(42);
+    \endrst
+   */
+  FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+  FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(const wchar_t *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+#endif // FMT_USE_UDL_TEMPLATE
 
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::arg`.
+  /**
+    \rst
+    User-defined literal equivalent of :func:`fmt::arg`.
 
-  **Example**::
+    **Example**::
 
-    using namespace fmt::literals;
-    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
-                                                    std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
-                                                       std::size_t n) {
-  return {{s, n}};
-}
-}  // namespace literals
-#endif  // FMT_USE_USER_DEFINED_LITERALS
+      using namespace fmt::literals;
+      fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+    \endrst
+   */
+  FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+  FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t *s, std::size_t n)
+  {
+    return {{s, n}};
+  }
+} // namespace literals
+#endif // FMT_USE_USER_DEFINED_LITERALS
 FMT_END_NAMESPACE
 
 /**
@@ -3557,19 +3748,20 @@ FMT_END_NAMESPACE
     std::string s = format(FMT_STRING("{:d}"), "foo");
   \endrst
  */
-#define FMT_STRING(s)                                                    \
-  [] {                                                                   \
-    struct str : fmt::compile_string {                                   \
-      using char_type = typename std::remove_cv<std::remove_pointer<     \
-          typename std::decay<decltype(s)>::type>::type>::type;          \
-      FMT_CONSTEXPR operator fmt::basic_string_view<char_type>() const { \
-        return {s, sizeof(s) / sizeof(char_type) - 1};                   \
-      }                                                                  \
-    } result;                                                            \
-    /* Suppress Qt Creator warning about unused operator. */             \
-    (void)static_cast<fmt::basic_string_view<typename str::char_type>>(  \
-        result);                                                         \
-    return result;                                                       \
+#define FMT_STRING(s)                                                                              \
+  [] {                                                                                             \
+    struct str : fmt::compile_string                                                               \
+    {                                                                                              \
+      using char_type = typename std::remove_cv<                                                   \
+          std::remove_pointer<typename std::decay<decltype(s)>::type>::type>::type;                \
+      FMT_CONSTEXPR operator fmt::basic_string_view<char_type>() const                             \
+      {                                                                                            \
+        return {s, sizeof(s) / sizeof(char_type) - 1};                                             \
+      }                                                                                            \
+    } result;                                                                                      \
+    /* Suppress Qt Creator warning about unused operator. */                                       \
+    (void)static_cast<fmt::basic_string_view<typename str::char_type>>(result);                    \
+    return result;                                                                                 \
   }()
 
 #if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
@@ -3587,14 +3779,14 @@ FMT_END_NAMESPACE
     std::string s = format(fmt("{:d}"), "foo");
   \endrst
  */
-#  define fmt(s) FMT_STRING(s)
+#define fmt(s) FMT_STRING(s)
 #endif
 
 #ifdef FMT_HEADER_ONLY
-#  define FMT_FUNC inline
-#  include "format-inl.h"
+#define FMT_FUNC inline
+#include "format-inl.h"
 #else
-#  define FMT_FUNC
+#define FMT_FUNC
 #endif
 
-#endif  // FMT_FORMAT_H_
+#endif // FMT_FORMAT_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/ostream.h b/packages/seacas/libraries/suplib_cpp/fmt/ostream.h
index 69bac0e24a13..c747f640d024 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/ostream.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/ostream.h
@@ -8,109 +8,118 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include <ostream>
 #include "format.h"
+#include <ostream>
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-template <class Char> class formatbuf : public std::basic_streambuf<Char> {
- private:
-  using int_type = typename std::basic_streambuf<Char>::int_type;
-  using traits_type = typename std::basic_streambuf<Char>::traits_type;
-
-  buffer<Char>& buffer_;
-
- public:
-  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
-
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
+  template <class Char> class formatbuf : public std::basic_streambuf<Char>
+  {
+  private:
+    using int_type    = typename std::basic_streambuf<Char>::int_type;
+    using traits_type = typename std::basic_streambuf<Char>::traits_type;
+
+    buffer<Char> &buffer_;
+
+  public:
+    formatbuf(buffer<Char> &buf) : buffer_(buf) {}
+
+  protected:
+    // The put-area is actually always empty. This makes the implementation
+    // simpler and has the advantage that the streambuf and the buffer are always
+    // in sync and sputc never writes into uninitialized memory. The obvious
+    // disadvantage is that each call to sputc always results in a (virtual) call
+    // to overflow. There is no disadvantage here for sputn since this always
+    // results in a call to xsputn.
+
+    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
+    {
+      if (!traits_type::eq_int_type(ch, traits_type::eof()))
+        buffer_.push_back(static_cast<Char>(ch));
+      return ch;
+    }
+
+    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
+    {
+      buffer_.append(s, s + count);
+      return count;
+    }
+  };
+
+  template <typename Char> struct test_stream : std::basic_ostream<Char>
+  {
+  private:
+    // Hide all operator<< from std::basic_ostream<Char>.
+    void_t<> operator<<(null<>);
+    void_t<> operator<<(const Char *);
+
+    template <typename T,
+              FMT_ENABLE_IF(std::is_convertible<T, int>::value && !std::is_enum<T>::value)>
+    void_t<> operator<<(T);
+  };
+
+  // Checks if T has a user-defined operator<< (e.g. not a member of
+  // std::ostream).
+  template <typename T, typename Char> class is_streamable
+  {
+  private:
+    template <typename U>
+    static bool_constant<!std::is_same<
+        decltype(std::declval<test_stream<Char> &>() << std::declval<U>()), void_t<>>::value>
+    test(int);
+
+    template <typename> static std::false_type test(...);
+
+    using result = decltype(test<T>(0));
+
+  public:
+    static const bool value = result::value;
+  };
+
+  // Write the content of buf to os.
+  template <typename Char> void write(std::basic_ostream<Char> &os, buffer<Char> &buf)
+  {
+    const Char *buf_data         = buf.data();
+    using unsigned_streamsize    = std::make_unsigned<std::streamsize>::type;
+    unsigned_streamsize size     = buf.size();
+    unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+    do {
+      unsigned_streamsize n = size <= max_size ? size : max_size;
+      os.write(buf_data, static_cast<std::streamsize>(n));
+      buf_data += n;
+      size -= n;
+    } while (size != 0);
   }
 
-  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
+  template <typename Char, typename T> void format_value(buffer<Char> &buf, const T &value)
+  {
+    formatbuf<Char>          format_buf(buf);
+    std::basic_ostream<Char> output(&format_buf);
+    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+    output << value;
+    buf.resize(buf.size());
   }
-};
-
-template <typename Char> struct test_stream : std::basic_ostream<Char> {
- private:
-  struct null;
-  // Hide all operator<< from std::basic_ostream<Char>.
-  void operator<<(null);
-};
-
-// Checks if T has a user-defined operator<< (e.g. not a member of
-// std::ostream).
-template <typename T, typename Char> class is_streamable {
- private:
-  template <typename U>
-  static decltype((void)(std::declval<test_stream<Char>&>()
-                         << std::declval<U>()),
-                  std::true_type())
-  test(int);
-
-  template <typename> static std::false_type test(...);
-
-  using result = decltype(test<T>(0));
-
- public:
-  static const bool value = result::value;
-};
-
-// Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char>& os, buffer<Char>& buf) {
-  const Char* buf_data = buf.data();
-  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
-  unsigned_streamsize size = buf.size();
-  unsigned_streamsize max_size =
-      to_unsigned((std::numeric_limits<std::streamsize>::max)());
-  do {
-    unsigned_streamsize n = size <= max_size ? size : max_size;
-    os.write(buf_data, static_cast<std::streamsize>(n));
-    buf_data += n;
-    size -= n;
-  } while (size != 0);
-}
 
-template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value) {
-  formatbuf<Char> format_buf(buf);
-  std::basic_ostream<Char> output(&format_buf);
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  output << value;
-  buf.resize(buf.size());
-}
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
-    : formatter<basic_string_view<Char>, Char> {
-  template <typename Context>
-  auto format(const T& value, Context& ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buffer;
-    format_value(buffer, value);
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-  }
-};
-}  // namespace internal
+  // Formats an object of type T that has an overloaded ostream operator<<.
+  template <typename T, typename Char>
+  struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+      : formatter<basic_string_view<Char>, Char>
+  {
+    template <typename Context> auto format(const T &value, Context &ctx) -> decltype(ctx.out())
+    {
+      basic_memory_buffer<Char> buffer;
+      format_value(buffer, value);
+      basic_string_view<Char> str(buffer.data(), buffer.size());
+      return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+    }
+  };
+} // namespace internal
 
 template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
-            basic_format_args<buffer_context<Char>> args) {
+void vprint(std::basic_ostream<Char> &os, basic_string_view<Char> format_str,
+            basic_format_args<buffer_context<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   internal::write(os, buffer);
@@ -127,10 +136,11 @@ void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
  */
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+void print(std::basic_ostream<Char> &os, const S &format_str, Args &&... args)
+{
   vprint(os, to_string_view(format_str),
          {internal::make_args_checked<Args...>(format_str, args...)});
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_OSTREAM_H_
+#endif // FMT_OSTREAM_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/printf.h b/packages/seacas/libraries/suplib_cpp/fmt/printf.h
index c3c330405ef3..9fd493855764 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/printf.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/printf.h
@@ -8,188 +8,202 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#include <algorithm>  // std::fill_n
-#include <limits>     // std::numeric_limits
+#include <algorithm> // std::fill_n
+#include <limits>    // std::numeric_limits
 
 #include "ostream.h"
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T> inline T const_check(T value) { return value; }
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned> struct int_checker {
-  template <typename T> static bool fits_in_int(T value) {
-    unsigned max = std::numeric_limits<int>::max();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
-};
-
-template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
-    return value >= std::numeric_limits<int>::min() &&
-           value <= std::numeric_limits<int>::max();
-  }
-  static bool fits_in_int(int) { return true; }
-};
-
-class printf_precision_handler {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
-    return (std::max)(static_cast<int>(value), 0);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  int operator()(T) {
-    FMT_THROW(format_error("precision is not integer"));
-    return 0;
-  }
-};
+  // Checks if a value fits in int - used to avoid warnings about comparing
+  // signed and unsigned integers.
+  template <bool IsSigned> struct int_checker
+  {
+    template <typename T> static bool fits_in_int(T value)
+    {
+      unsigned max = max_value<int>();
+      return value <= max;
+    }
+    static bool fits_in_int(bool) { return true; }
+  };
+
+  template <> struct int_checker<true>
+  {
+    template <typename T> static bool fits_in_int(T value)
+    {
+      return value >= std::numeric_limits<int>::min() && value <= max_value<int>();
+    }
+    static bool fits_in_int(int) { return true; }
+  };
+
+  class printf_precision_handler
+  {
+  public:
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> int operator()(T value)
+    {
+      if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+        FMT_THROW(format_error("number is too big"));
+      return (std::max)(static_cast<int>(value), 0);
+    }
 
-// An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
-    return value == 0;
-  }
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> int operator()(T)
+    {
+      FMT_THROW(format_error("precision is not integer"));
+      return 0;
+    }
+  };
+
+  // An argument visitor that returns true iff arg is a zero integer.
+  class is_zero_int
+  {
+  public:
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> bool operator()(T value)
+    {
+      return value == 0;
+    }
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
-    return false;
-  }
-};
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> bool operator()(T)
+    {
+      return false;
+    }
+  };
 
-template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
+  template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T>
+  {
+  };
 
-template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+  template <> struct make_unsigned_or_bool<bool>
+  {
+    using type = bool;
+  };
 
-template <typename T, typename Context> class arg_converter {
- private:
-  using char_type = typename Context::char_type;
+  template <typename T, typename Context> class arg_converter
+  {
+  private:
+    using char_type = typename Context::char_type;
 
-  basic_format_arg<Context>& arg_;
-  char_type type_;
+    basic_format_arg<Context> &arg_;
+    char_type                  type_;
 
- public:
-  arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
+  public:
+    arg_converter(basic_format_arg<Context> &arg, char_type type) : arg_(arg), type_(type) {}
 
-  void operator()(bool value) {
-    if (type_ != 's') operator()<bool>(value);
-  }
+    void operator()(bool value)
+    {
+      if (type_ != 's')
+        operator()<bool>(value);
+    }
 
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
-    if (const_check(sizeof(target_type) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-            static_cast<int>(static_cast<target_type>(value)));
-      } else {
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        arg_ = internal::make_arg<Context>(
-            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+    template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)> void operator()(U value)
+    {
+      bool is_signed    = type_ == 'd' || type_ == 'i';
+      using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+      if (const_check(sizeof(target_type) <= sizeof(int))) {
+        // Extra casts are used to silence warnings.
+        if (is_signed) {
+          arg_ = internal::make_arg<Context>(static_cast<int>(static_cast<target_type>(value)));
+        }
+        else {
+          using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+          arg_ =
+              internal::make_arg<Context>(static_cast<unsigned>(static_cast<unsigned_type>(value)));
+        }
       }
-    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
-      } else {
-        arg_ = internal::make_arg<Context>(
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      else {
+        if (is_signed) {
+          // glibc's printf doesn't sign extend arguments of smaller types:
+          //   std::printf("%lld", -42);  // prints "4294967254"
+          // but we don't have to do the same because it's a UB.
+          arg_ = internal::make_arg<Context>(static_cast<long long>(value));
+        }
+        else {
+          arg_ = internal::make_arg<Context>(
+              static_cast<typename make_unsigned_or_bool<U>::type>(value));
+        }
       }
     }
-  }
 
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
-};
+    template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+    void operator()(U) {} // No conversion needed for non-integral types.
+  };
+
+  // Converts an integer argument to T for printf, if T is an integral type.
+  // If T is void, the argument is converted to corresponding signed or unsigned
+  // type depending on the type specifier: 'd' and 'i' - signed, other -
+  // unsigned).
+  template <typename T, typename Context, typename Char>
+  void convert_arg(basic_format_arg<Context> &arg, Char type)
+  {
+    visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+  }
 
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
-}
+  // Converts an integer argument to char for printf.
+  template <typename Context> class char_converter
+  {
+  private:
+    basic_format_arg<Context> &arg_;
 
-// Converts an integer argument to char for printf.
-template <typename Context> class char_converter {
- private:
-  basic_format_arg<Context>& arg_;
+  public:
+    explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
 
- public:
-  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> void operator()(T value)
+    {
+      arg_ = internal::make_arg<Context>(static_cast<typename Context::char_type>(value));
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  void operator()(T value) {
-    arg_ = internal::make_arg<Context>(
-        static_cast<typename Context::char_type>(value));
-  }
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+    void operator()(T) {} // No conversion needed for non-integral types.
+  };
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  void operator()(T) {}  // No conversion needed for non-integral types.
-};
+  // Checks if an argument is a valid printf width specifier and sets
+  // left alignment if it is negative.
+  template <typename Char> class printf_width_handler
+  {
+  private:
+    using format_specs = basic_format_specs<Char>;
 
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-template <typename Char> class printf_width_handler {
- private:
-  using format_specs = basic_format_specs<Char>;
+    format_specs &specs_;
 
-  format_specs& specs_;
+  public:
+    explicit printf_width_handler(format_specs &specs) : specs_(specs) {}
 
- public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+    template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> unsigned operator()(T value)
+    {
+      auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+      if (internal::is_negative(value)) {
+        specs_.align = align::left;
+        width        = 0 - width;
+      }
+      unsigned int_max = max_value<int>();
+      if (width > int_max)
+        FMT_THROW(format_error("number is too big"));
+      return static_cast<unsigned>(width);
+    }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(T value) {
-    auto width = static_cast<uint32_or_64_t<T>>(value);
-    if (internal::is_negative(value)) {
-      specs_.align = align::left;
-      width = 0 - width;
+    template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> unsigned operator()(T)
+    {
+      FMT_THROW(format_error("width is not integer"));
+      return 0;
     }
-    unsigned int_max = std::numeric_limits<int>::max();
-    if (width > int_max) FMT_THROW(format_error("number is too big"));
-    return static_cast<unsigned>(width);
-  }
+  };
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  unsigned operator()(T) {
-    FMT_THROW(format_error("width is not integer"));
-    return 0;
+  template <typename Char, typename Context>
+  void printf(buffer<Char> &buf, basic_string_view<Char> format, basic_format_args<Context> args)
+  {
+    Context(std::back_inserter(buf), format, args).format();
   }
-};
-
-template <typename Char, typename Context>
-void printf(buffer<Char>& buf, basic_string_view<Char> format,
-            basic_format_args<Context> args) {
-  Context(std::back_inserter(buf), format, args).format();
-}
 
-template <typename OutputIt, typename Char, typename Context>
-internal::truncating_iterator<OutputIt> printf(
-    internal::truncating_iterator<OutputIt> it, basic_string_view<Char> format,
-    basic_format_args<Context> args) {
-  return Context(it, format, args).format();
-}
-}  // namespace internal
+  template <typename OutputIt, typename Char, typename Context>
+  internal::truncating_iterator<OutputIt> printf(internal::truncating_iterator<OutputIt> it,
+                                                 basic_string_view<Char>                 format,
+                                                 basic_format_args<Context>              args)
+  {
+    return Context(it, format, args).format();
+  }
+} // namespace internal
 
-using internal::printf;  // For printing into memory_buffer.
+using internal::printf; // For printing into memory_buffer.
 
 template <typename Range> class printf_arg_formatter;
 
@@ -200,29 +214,31 @@ template <typename OutputIt, typename Char> class basic_printf_context;
   The ``printf`` argument formatter.
   \endrst
  */
-template <typename Range>
-class printf_arg_formatter : public internal::arg_formatter_base<Range> {
- public:
+template <typename Range> class printf_arg_formatter : public internal::arg_formatter_base<Range>
+{
+public:
   using iterator = typename Range::iterator;
 
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
+private:
+  using char_type    = typename Range::value_type;
+  using base         = internal::arg_formatter_base<Range>;
   using context_type = basic_printf_context<iterator, char_type>;
 
-  context_type& context_;
+  context_type &context_;
 
-  void write_null_pointer(char) {
+  void write_null_pointer(char)
+  {
     this->specs()->type = 0;
     this->write("(nil)");
   }
 
-  void write_null_pointer(wchar_t) {
+  void write_null_pointer(wchar_t)
+  {
     this->specs()->type = 0;
     this->write(L"(nil)");
   }
 
- public:
+public:
   using format_specs = typename base::format_specs;
 
   /**
@@ -232,39 +248,47 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
     specifier information for standard argument types.
     \endrst
    */
-  printf_arg_formatter(iterator iter, format_specs& my_specs, context_type& ctx)
-      : base(Range(iter), &my_specs, internal::locale_ref()), context_(ctx) {}
+  printf_arg_formatter(iterator iter, format_specs &specs, context_type &ctx)
+      : base(Range(iter), &specs, internal::locale_ref()), context_(ctx)
+  {
+  }
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  iterator operator()(T value) {
+  template <typename T, FMT_ENABLE_IF(fmt::internal::is_integral<T>::value)>
+  iterator operator()(T value)
+  {
     // MSVC2013 fails to compile separate overloads for bool and char_type so
     // use std::is_same instead.
     if (std::is_same<T, bool>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
+      format_specs &fmt_specs = *this->specs();
+      if (fmt_specs.type != 's')
+        return base::operator()(value ? 1 : 0);
       fmt_specs.type = 0;
       this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs& fmt_specs = *this->specs();
+    }
+    else if (std::is_same<T, char_type>::value) {
+      format_specs &fmt_specs = *this->specs();
       if (fmt_specs.type && fmt_specs.type != 'c')
         return (*this)(static_cast<int>(value));
-      fmt_specs.sign = sign::none;
-      fmt_specs.alt = false;
+      fmt_specs.sign  = sign::none;
+      fmt_specs.alt   = false;
       fmt_specs.align = align::right;
       return base::operator()(value);
-    } else {
+    }
+    else {
       return base::operator()(value);
     }
     return this->out();
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
+  iterator operator()(T value)
+  {
     return base::operator()(value);
   }
 
   /** Formats a null-terminated C string. */
-  iterator operator()(const char* value) {
+  iterator operator()(const char *value)
+  {
     if (value)
       base::operator()(value);
     else if (this->specs()->type == 'p')
@@ -275,7 +299,8 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
   }
 
   /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t* value) {
+  iterator operator()(const wchar_t *value)
+  {
     if (value)
       base::operator()(value);
     else if (this->specs()->type == 'p')
@@ -285,66 +310,69 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
     return this->out();
   }
 
-  iterator operator()(basic_string_view<char_type> value) {
-    return base::operator()(value);
-  }
+  iterator operator()(basic_string_view<char_type> value) { return base::operator()(value); }
 
   iterator operator()(monostate value) { return base::operator()(value); }
 
   /** Formats a pointer. */
-  iterator operator()(const void* value) {
-    if (value) return base::operator()(value);
+  iterator operator()(const void *value)
+  {
+    if (value)
+      return base::operator()(value);
     this->specs()->type = 0;
     write_null_pointer(char_type());
     return this->out();
   }
 
   /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+  iterator operator()(typename basic_format_arg<context_type>::handle handle)
+  {
     handle.format(context_.parse_context(), context_);
     return this->out();
   }
 };
 
-template <typename T> struct printf_formatter {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+template <typename T> struct printf_formatter
+{
+  template <typename ParseContext> auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return ctx.begin();
   }
 
   template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out())
+  {
     internal::format_value(internal::get_container(ctx.out()), value);
     return ctx.out();
   }
 };
 
 /** This template formats data and writes the output to a writer. */
-template <typename OutputIt, typename Char> class basic_printf_context {
- public:
+template <typename OutputIt, typename Char> class basic_printf_context
+{
+public:
   /** The character type for the output. */
-  using char_type = Char;
-  using format_arg = basic_format_arg<basic_printf_context>;
+  using char_type                            = Char;
+  using format_arg                           = basic_format_arg<basic_printf_context>;
   template <typename T> using formatter_type = printf_formatter<T>;
 
- private:
+private:
   using format_specs = basic_format_specs<char_type>;
 
-  OutputIt out_;
+  OutputIt                                out_;
   basic_format_args<basic_printf_context> args_;
-  basic_parse_context<Char> parse_ctx_;
+  basic_parse_context<Char>               parse_ctx_;
 
-  static void parse_flags(format_specs& specs, const Char*& it,
-                          const Char* end);
+  static void parse_flags(format_specs &specs, const Char *&it, const Char *end);
 
   // Returns the argument with specified index or, if arg_index is equal
   // to the maximum unsigned value, the next argument.
-  format_arg get_arg(unsigned arg_index = std::numeric_limits<unsigned>::max());
+  format_arg get_arg(unsigned arg_index = internal::max_value<unsigned>());
 
   // Parses argument index, flags and width and returns the argument index.
-  unsigned parse_header(const Char*& it, const Char* end, format_specs& specs);
+  unsigned parse_header(const Char *&it, const Char *end, format_specs &specs);
 
- public:
+public:
   /**
    \rst
    Constructs a ``printf_context`` object. References to the arguments and
@@ -352,58 +380,46 @@ template <typename OutputIt, typename Char> class basic_printf_context {
    appropriate lifetimes.
    \endrst
    */
-  basic_printf_context(OutputIt it_out, basic_string_view<char_type> format_str,
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
                        basic_format_args<basic_printf_context> args)
-      : out_(it_out), args_(args), parse_ctx_(format_str) {}
+      : out_(out), args_(args), parse_ctx_(format_str)
+  {
+  }
 
   OutputIt out() { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
+  void     advance_to(OutputIt it) { out_ = it; }
 
   format_arg arg(unsigned id) const { return args_.get(id); }
 
-  basic_parse_context<Char>& parse_context() { return parse_ctx_; }
+  basic_parse_context<Char> &parse_context() { return parse_ctx_; }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
-    parse_ctx_.on_error(message);
-  }
+  FMT_CONSTEXPR void on_error(const char *message) { parse_ctx_.on_error(message); }
 
   /** Formats stored arguments and writes the output to the range. */
-  template <typename ArgFormatter =
-                printf_arg_formatter<internal::buffer_range<Char>>>
-  OutputIt format();
+  template <typename ArgFormatter = printf_arg_formatter<buffer_range<Char>>> OutputIt format();
 };
 
 template <typename OutputIt, typename Char>
-void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
-                                                       const Char*& it,
-                                                       const Char* end) {
+void basic_printf_context<OutputIt, Char>::parse_flags(format_specs &specs, const Char *&it,
+                                                       const Char *end)
+{
   for (; it != end; ++it) {
     switch (*it) {
-    case '-':
-      specs.align = align::left;
-      break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill[0] = '0';
-      break;
-    case ' ':
-      specs.sign = sign::space;
-      break;
-    case '#':
-      specs.alt = true;
-      break;
-    default:
-      return;
+    case '-': specs.align = align::left; break;
+    case '+': specs.sign = sign::plus; break;
+    case '0': specs.fill[0] = '0'; break;
+    case ' ': specs.sign = sign::space; break;
+    case '#': specs.alt = true; break;
+    default: return;
     }
   }
 }
 
 template <typename OutputIt, typename Char>
 typename basic_printf_context<OutputIt, Char>::format_arg
-basic_printf_context<OutputIt, Char>::get_arg(unsigned arg_index) {
-  if (arg_index == std::numeric_limits<unsigned>::max())
+basic_printf_context<OutputIt, Char>::get_arg(unsigned arg_index)
+{
+  if (arg_index == internal::max_value<unsigned>())
     arg_index = parse_ctx_.next_arg_id();
   else
     parse_ctx_.check_arg_id(--arg_index);
@@ -411,20 +427,23 @@ basic_printf_context<OutputIt, Char>::get_arg(unsigned arg_index) {
 }
 
 template <typename OutputIt, typename Char>
-unsigned basic_printf_context<OutputIt, Char>::parse_header(
-    const Char*& it, const Char* end, format_specs& specs) {
-  unsigned arg_index = std::numeric_limits<unsigned>::max();
-  char_type c = *it;
+unsigned basic_printf_context<OutputIt, Char>::parse_header(const Char *&it, const Char *end,
+                                                            format_specs &specs)
+{
+  unsigned  arg_index = internal::max_value<unsigned>();
+  char_type c         = *it;
   if (c >= '0' && c <= '9') {
     // Parse an argument index (if followed by '$') or a width possibly
     // preceded with '0' flag(s).
     internal::error_handler eh;
-    unsigned value = parse_nonnegative_int(it, end, eh);
-    if (it != end && *it == '$') {  // value is an argument index
+    unsigned                value = parse_nonnegative_int(it, end, eh);
+    if (it != end && *it == '$') { // value is an argument index
       ++it;
       arg_index = value;
-    } else {
-      if (c == '0') specs.fill[0] = '0';
+    }
+    else {
+      if (c == '0')
+        specs.fill[0] = '0';
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
@@ -439,10 +458,10 @@ unsigned basic_printf_context<OutputIt, Char>::parse_header(
     if (*it >= '0' && *it <= '9') {
       internal::error_handler eh;
       specs.width = parse_nonnegative_int(it, end, eh);
-    } else if (*it == '*') {
+    }
+    else if (*it == '*') {
       ++it;
-      specs.width = visit_format_arg(
-          internal::printf_width_handler<char_type>(specs), get_arg());
+      specs.width = visit_format_arg(internal::printf_width_handler<char_type>(specs), get_arg());
     }
   }
   return arg_index;
@@ -450,26 +469,30 @@ unsigned basic_printf_context<OutputIt, Char>::parse_header(
 
 template <typename OutputIt, typename Char>
 template <typename ArgFormatter>
-OutputIt basic_printf_context<OutputIt, Char>::format() {
-  auto my_out = this->out();
-  const Char* start = parse_ctx_.begin();
-  const Char* end = parse_ctx_.end();
-  auto it = start;
+OutputIt basic_printf_context<OutputIt, Char>::format()
+{
+  auto        out   = this->out();
+  const Char *start = parse_ctx_.begin();
+  const Char *end   = parse_ctx_.end();
+  auto        it    = start;
   while (it != end) {
     char_type c = *it++;
-    if (c != '%') continue;
+    if (c != '%')
+      continue;
     if (it != end && *it == c) {
-      my_out = std::copy(start, it, my_out);
+      out   = std::copy(start, it, out);
       start = ++it;
       continue;
     }
-    my_out = std::copy(start, it - 1, my_out);
+    out = std::copy(start, it - 1, out);
 
     format_specs specs;
     specs.align = align::right;
 
     // Parse argument index, flags and width.
     unsigned arg_index = parse_header(it, end, specs);
+    if (arg_index == 0)
+      on_error("argument index out of range");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -478,27 +501,28 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       if ('0' <= c && c <= '9') {
         internal::error_handler eh;
         specs.precision = static_cast<int>(parse_nonnegative_int(it, end, eh));
-      } else if (c == '*') {
+      }
+      else if (c == '*') {
         ++it;
-        specs.precision =
-            visit_format_arg(internal::printf_precision_handler(), get_arg());
-      } else {
+        specs.precision = visit_format_arg(internal::printf_precision_handler(), get_arg());
+      }
+      else {
         specs.precision = 0;
       }
     }
 
-    format_arg my_arg = get_arg(arg_index);
-    if (specs.alt && visit_format_arg(internal::is_zero_int(), my_arg))
+    format_arg arg = get_arg(arg_index);
+    if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
       specs.alt = false;
     if (specs.fill[0] == '0') {
-      if (my_arg.is_arithmetic())
+      if (arg.is_arithmetic())
         specs.align = align::numeric;
       else
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types.
+        specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types.
     }
 
     // Parse length and convert the argument to the required type.
-    c = it != end ? *it++ : 0;
+    c           = it != end ? *it++ : 0;
     char_type t = it != end ? *it : 0;
     using internal::convert_arg;
     switch (c) {
@@ -506,72 +530,61 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       if (t == 'h') {
         ++it;
         t = it != end ? *it : 0;
-        convert_arg<signed char>(my_arg, t);
-      } else {
-        convert_arg<short>(my_arg, t);
+        convert_arg<signed char>(arg, t);
+      }
+      else {
+        convert_arg<short>(arg, t);
       }
       break;
     case 'l':
       if (t == 'l') {
         ++it;
         t = it != end ? *it : 0;
-        convert_arg<long long>(my_arg, t);
-      } else {
-        convert_arg<long>(my_arg, t);
+        convert_arg<long long>(arg, t);
+      }
+      else {
+        convert_arg<long>(arg, t);
       }
       break;
-    case 'j':
-      convert_arg<intmax_t>(my_arg, t);
-      break;
-    case 'z':
-      convert_arg<std::size_t>(my_arg, t);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(my_arg, t);
-      break;
+    case 'j': convert_arg<intmax_t>(arg, t); break;
+    case 'z': convert_arg<std::size_t>(arg, t); break;
+    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
     case 'L':
       // printf produces garbage when 'L' is omitted for long double, no
       // need to do the same.
       break;
-    default:
-      --it;
-      convert_arg<void>(my_arg, c);
+    default: --it; convert_arg<void>(arg, c);
     }
 
     // Parse type.
-    if (it == end) FMT_THROW(format_error("invalid format string"));
+    if (it == end)
+      FMT_THROW(format_error("invalid format string"));
     specs.type = static_cast<char>(*it++);
-    if (my_arg.is_integral()) {
+    if (arg.is_integral()) {
       // Normalize type.
       switch (specs.type) {
       case 'i':
-      case 'u':
-        specs.type = 'd';
-        break;
-      case 'c':
-        visit_format_arg(internal::char_converter<basic_printf_context>(my_arg),
-                         my_arg);
-        break;
+      case 'u': specs.type = 'd'; break;
+      case 'c': visit_format_arg(internal::char_converter<basic_printf_context>(arg), arg); break;
       }
     }
 
     start = it;
 
     // Format argument.
-    visit_format_arg(ArgFormatter(my_out, specs, *this), my_arg);
+    visit_format_arg(ArgFormatter(out, specs, *this), arg);
   }
-  return std::copy(start, it, my_out);
+  return std::copy(start, it, out);
 }
 
 template <typename Char>
 using basic_printf_context_t =
-    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>,
-                         Char>;
+    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>, Char>;
 
-using printf_context = basic_printf_context_t<char>;
+using printf_context  = basic_printf_context_t<char>;
 using wprintf_context = basic_printf_context_t<wchar_t>;
 
-using printf_args = basic_format_args<printf_context>;
+using printf_args  = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;
 
 /**
@@ -581,8 +594,8 @@ using wprintf_args = basic_format_args<wprintf_context>;
   \endrst
  */
 template <typename... Args>
-inline format_arg_store<printf_context, Args...> make_printf_args(
-    const Args&... args) {
+inline format_arg_store<printf_context, Args...> make_printf_args(const Args &... args)
+{
   return {args...};
 }
 
@@ -593,14 +606,15 @@ inline format_arg_store<printf_context, Args...> make_printf_args(
   \endrst
  */
 template <typename... Args>
-inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
-    const Args&... args) {
+inline format_arg_store<wprintf_context, Args...> make_wprintf_args(const Args &... args)
+{
   return {args...};
 }
 
 template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vsprintf(
-    const S& format, basic_format_args<basic_printf_context_t<Char>> args) {
+inline std::basic_string<Char> vsprintf(const S &                                       format,
+                                        basic_format_args<basic_printf_context_t<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   return to_string(buffer);
@@ -617,20 +631,20 @@ inline std::basic_string<Char> vsprintf(
 */
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
+inline std::basic_string<Char> sprintf(const S &format, const Args &... args)
+{
   using context = basic_printf_context_t<Char>;
   return vsprintf(to_string_view(format), {make_format_args<context>(args...)});
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::FILE* f, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
+inline int vfprintf(std::FILE *f, const S &format,
+                    basic_format_args<basic_printf_context_t<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   std::size_t size = buffer.size();
-  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
-             ? -1
-             : static_cast<int>(size);
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
 }
 
 /**
@@ -644,15 +658,15 @@ inline int vfprintf(std::FILE* f, const S& format,
  */
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
+inline int fprintf(std::FILE *f, const S &format, const Args &... args)
+{
   using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(format),
-                  {make_format_args<context>(args...)});
+  return vfprintf(f, to_string_view(format), {make_format_args<context>(args...)});
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vprintf(const S& format,
-                   basic_format_args<basic_printf_context_t<Char>> args) {
+inline int vprintf(const S &format, basic_format_args<basic_printf_context_t<Char>> args)
+{
   return vfprintf(stdout, to_string_view(format), args);
 }
 
@@ -665,17 +679,17 @@ inline int vprintf(const S& format,
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline int printf(const S& format_str, const Args&... args) {
+template <typename S, typename... Args, FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline int printf(const S &format_str, const Args &... args)
+{
   using context = basic_printf_context_t<char_t<S>>;
-  return vprintf(to_string_view(format_str),
-                 {make_format_args<context>(args...)});
+  return vprintf(to_string_view(format_str), {make_format_args<context>(args...)});
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::basic_ostream<Char>& os, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
+inline int vfprintf(std::basic_ostream<Char> &os, const S &format,
+                    basic_format_args<basic_printf_context_t<Char>> args)
+{
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   internal::write(os, buffer);
@@ -684,11 +698,11 @@ inline int vfprintf(std::basic_ostream<Char>& os, const S& format,
 
 /** Formats arguments and writes the output to the range. */
 template <typename ArgFormatter, typename Char,
-          typename Context =
-              basic_printf_context<typename ArgFormatter::iterator, Char>>
-typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
-                                        basic_string_view<Char> format_str,
-                                        basic_format_args<Context> args) {
+          typename Context = basic_printf_context<typename ArgFormatter::iterator, Char>>
+typename ArgFormatter::iterator vprintf(internal::buffer<Char> &   out,
+                                        basic_string_view<Char>    format_str,
+                                        basic_format_args<Context> args)
+{
   typename ArgFormatter::iterator iter(out);
   Context(iter, format_str, args).template format<ArgFormatter>();
   return iter;
@@ -704,12 +718,11 @@ typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
   \endrst
  */
 template <typename S, typename... Args, typename Char = char_t<S>>
-inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
-                   const Args&... args) {
+inline int fprintf(std::basic_ostream<Char> &os, const S &format_str, const Args &... args)
+{
   using context = basic_printf_context_t<Char>;
-  return vfprintf(os, to_string_view(format_str),
-                  {make_format_args<context>(args...)});
+  return vfprintf(os, to_string_view(format_str), {make_format_args<context>(args...)});
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_PRINTF_H_
+#endif // FMT_PRINTF_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/ranges.h b/packages/seacas/libraries/suplib_cpp/fmt/ranges.h
index cf0d41aaa5ee..6325f642d3d3 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/ranges.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/ranges.h
@@ -12,28 +12,30 @@
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
 
-#include <type_traits>
 #include "format.h"
+#include <type_traits>
 
 // output only up to N items from the range.
 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-#  define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
 #endif
 
 FMT_BEGIN_NAMESPACE
 
-template <typename Char> struct formatting_base {
+template <typename Char> struct formatting_base
+{
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return ctx.begin();
   }
 };
 
-template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char> {
+template <typename Char, typename Enable = void> struct formatting_range : formatting_base<Char>
+{
   static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
-                                      // range.
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the
+                                     // range.
   Char prefix;
   Char delimiter;
   Char postfix;
@@ -42,8 +44,8 @@ struct formatting_range : formatting_base<Char> {
   static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
-template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char> {
+template <typename Char, typename Enable = void> struct formatting_tuple : formatting_base<Char>
+{
   Char prefix;
   Char delimiter;
   Char postfix;
@@ -54,182 +56,199 @@ struct formatting_tuple : formatting_base<Char> {
 
 namespace internal {
 
-template <typename RangeT, typename OutputIterator>
-OutputIterator copy(const RangeT& range, OutputIterator out) {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
-  return out;
-}
+  template <typename RangeT, typename OutputIterator>
+  OutputIterator copy(const RangeT &range, OutputIterator out)
+  {
+    for (auto it = range.begin(), end = range.end(); it != end; ++it)
+      *out++ = *it;
+    return out;
+  }
 
-template <typename OutputIterator>
-OutputIterator copy(const char* str, OutputIterator out) {
-  while (*str) *out++ = *str++;
-  return out;
-}
+  template <typename OutputIterator> OutputIterator copy(const char *str, OutputIterator out)
+  {
+    while (*str)
+      *out++ = *str++;
+    return out;
+  }
 
-template <typename OutputIterator>
-OutputIterator copy(char ch, OutputIterator out) {
-  *out++ = ch;
-  return out;
-}
+  template <typename OutputIterator> OutputIterator copy(char ch, OutputIterator out)
+  {
+    *out++ = ch;
+    return out;
+  }
 
-/// Return true value if T has std::string interface, like std::string_view.
-template <typename T> class is_like_std_string {
-  template <typename U>
-  static auto check(U* p)
-      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
-  template <typename> static void check(...);
+  /// Return true value if T has std::string interface, like std::string_view.
+  template <typename T> class is_like_std_string
+  {
+    template <typename U>
+    static auto check(U *p) -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+    template <typename> static void check(...);
 
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
-};
+  public:
+    static FMT_CONSTEXPR_DECL const bool value =
+        is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+  };
 
-template <typename Char>
-struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
+  template <typename Char> struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type
+  {
+  };
 
-template <typename... Ts> struct conditional_helper {};
+  template <typename... Ts> struct conditional_helper
+  {
+  };
 
-template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+  template <typename T, typename _ = void> struct is_range_ : std::false_type
+  {
+  };
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
-template <typename T>
-struct is_range_<
-    T, conditional_t<false,
-                     conditional_helper<decltype(std::declval<T>().begin()),
-                                        decltype(std::declval<T>().end())>,
-                     void>> : std::true_type {};
+  template <typename T>
+  struct is_range_<T, conditional_t<false,
+                                    conditional_helper<decltype(std::declval<T>().begin()),
+                                                       decltype(std::declval<T>().end())>,
+                                    void>> : std::true_type
+  {
+  };
 #endif
 
-/// tuple_size and tuple_element check.
-template <typename T> class is_tuple_like_ {
-  template <typename U>
-  static auto check(U* p)
-      -> decltype(std::tuple_size<U>::value,
-                  (void)std::declval<typename std::tuple_element<0, U>::type>(),
-                  int());
-  template <typename> static void check(...);
-
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
+  /// tuple_size and tuple_element check.
+  template <typename T> class is_tuple_like_
+  {
+    template <typename U>
+    static auto check(U *p)
+        -> decltype(std::tuple_size<U>::value,
+                    (void)std::declval<typename std::tuple_element<0, U>::type>(), int());
+    template <typename> static void check(...);
+
+  public:
+    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
+  };
 
 // Check for integer_sequence
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template <typename T, T... N>
-using integer_sequence = std::integer_sequence<T, N...>;
-template <std::size_t... N> using index_sequence = std::index_sequence<N...>;
-template <std::size_t N>
-using make_index_sequence = std::make_index_sequence<N>;
+  template <typename T, T... N> using integer_sequence = std::integer_sequence<T, N...>;
+  template <std::size_t... N> using index_sequence     = std::index_sequence<N...>;
+  template <std::size_t N> using make_index_sequence   = std::make_index_sequence<N>;
 #else
-template <typename T, T... N> struct integer_sequence {
-  using value_type = T;
+  template <typename T, T... N> struct integer_sequence
+  {
+    using value_type = T;
 
-  static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
-};
+    static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
+  };
 
-template <std::size_t... N>
-using index_sequence = integer_sequence<std::size_t, N...>;
+  template <std::size_t... N> using index_sequence = integer_sequence<std::size_t, N...>;
 
-template <typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-template <typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+  template <typename T, std::size_t N, T... Ns>
+  struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
+  {
+  };
+  template <typename T, T... Ns>
+  struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
+  {
+  };
 
-template <std::size_t N>
-using make_index_sequence = make_integer_sequence<std::size_t, N>;
+  template <std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;
 #endif
 
-template <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
-  using std::get;
-  // using free function get<I>(T) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  (void)_;  // blocks warnings
-}
+  template <class Tuple, class F, size_t... Is>
+  void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT
+  {
+    using std::get;
+    // using free function get<I>(T) now.
+    const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+    (void)_; // blocks warnings
+  }
 
-template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
-    T const&) {
-  return {};
-}
+  template <class T>
+  FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
+  {
+    return {};
+  }
 
-template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
-  const auto indexes = get_indexes(tup);
-  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
-}
+  template <class Tuple, class F> void for_each(Tuple &&tup, F &&f)
+  {
+    const auto indexes = get_indexes(tup);
+    for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+  }
 
-template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<
-                                      typename std::decay<Arg>::type>::value)>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
-  return add_space ? " {}" : "{}";
-}
+  template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<typename std::decay<Arg>::type>::value)>
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const Arg &)
+  {
+    return add_space ? " {}" : "{}";
+  }
 
-template <typename Arg, FMT_ENABLE_IF(is_like_std_string<
-                                      typename std::decay<Arg>::type>::value)>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
+  template <typename Arg, FMT_ENABLE_IF(is_like_std_string<typename std::decay<Arg>::type>::value)>
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const Arg &)
+  {
+    return add_space ? " \"{}\"" : "\"{}\"";
+  }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
-  return add_space ? L" \"{}\"" : L"\"{}\"";
-}
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *)
+  {
+    return add_space ? " \"{}\"" : "\"{}\"";
+  }
+  FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *)
+  {
+    return add_space ? L" \"{}\"" : L"\"{}\"";
+  }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
-  return add_space ? " '{}'" : "'{}'";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
-  return add_space ? L" '{}'" : L"'{}'";
-}
+  FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char)
+  {
+    return add_space ? " '{}'" : "'{}'";
+  }
+  FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t)
+  {
+    return add_space ? L" '{}'" : L"'{}'";
+  }
 
-}  // namespace internal
+} // namespace internal
 
-template <typename T> struct is_tuple_like {
+template <typename T> struct is_tuple_like
+{
   static FMT_CONSTEXPR_DECL const bool value =
       internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
 };
 
 template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
- private:
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>>
+{
+private:
   // C++11 generic lambda for format()
-  template <typename FormatContext> struct format_each {
-    template <typename T> void operator()(const T& v) {
+  template <typename FormatContext> struct format_each
+  {
+    template <typename T> void operator()(const T &v)
+    {
       if (i > 0) {
         if (formatting.add_prepostfix_space) {
           *out++ = ' ';
         }
         out = internal::copy(formatting.delimiter, out);
       }
-      out = format_to(out,
-                      internal::format_str_quoted(
-                          (formatting.add_delimiter_spaces && i > 0), v),
-                      v);
+      out = format_to(
+          out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v);
       ++i;
     }
 
-    formatting_tuple<Char>& formatting;
-    std::size_t& i;
-    typename std::add_lvalue_reference<decltype(
-        std::declval<FormatContext>().out())>::type out;
+    formatting_tuple<Char> &formatting;
+    std::size_t &           i;
+    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
   };
 
- public:
+public:
   formatting_tuple<Char> formatting;
 
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return formatting.parse(ctx);
   }
 
   template <typename FormatContext = format_context>
-  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    std::size_t i = 0;
+  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out())
+  {
+    auto        out = ctx.out();
+    std::size_t i   = 0;
     internal::copy(formatting.prefix, out);
 
     internal::for_each(values, format_each<FormatContext>{formatting, i, out});
@@ -242,47 +261,129 @@ struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
   }
 };
 
-template <typename T, typename Char> struct is_range {
+template <typename T, typename Char> struct is_range
+{
   static FMT_CONSTEXPR_DECL const bool value =
-      internal::is_range_<T>::value &&
-      !internal::is_like_std_string<T>::value &&
-      !std::is_convertible<T, std::basic_string<Char>>::value;
+      internal::is_range_<T>::value && !internal::is_like_std_string<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_constructible<internal::std_string_view<Char>, T>::value;
 };
 
 template <typename RangeT, typename Char>
-struct formatter<RangeT, Char,
-                 enable_if_t<fmt::is_range<RangeT, Char>::value>> {
+struct formatter<RangeT, Char, enable_if_t<fmt::is_range<RangeT, Char>::value>>
+{
   formatting_range<Char> formatting;
 
   template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
     return formatting.parse(ctx);
   }
 
   template <typename FormatContext>
-  typename FormatContext::iterator format(const RangeT& values,
-                                          FormatContext& ctx) {
-    auto out = internal::copy(formatting.prefix, ctx.out());
-    std::size_t i = 0;
+  typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx)
+  {
+    auto        out = internal::copy(formatting.prefix, ctx.out());
+    std::size_t i   = 0;
     for (auto it = values.begin(), end = values.end(); it != end; ++it) {
       if (i > 0) {
-        if (formatting.add_prepostfix_space) *out++ = ' ';
+        if (formatting.add_prepostfix_space)
+          *out++ = ' ';
         out = internal::copy(formatting.delimiter, out);
       }
-      out = format_to(out,
-                      internal::format_str_quoted(
-                          (formatting.add_delimiter_spaces && i > 0), *it),
-                      *it);
+      out = format_to(
+          out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it);
       if (++i > formatting.range_length_limit) {
         out = format_to(out, " ... <other elements>");
         break;
       }
     }
-    if (formatting.add_prepostfix_space) *out++ = ' ';
+    if (formatting.add_prepostfix_space)
+      *out++ = ' ';
     return internal::copy(formatting.postfix, out);
   }
 };
 
+template <typename Char, typename... T> struct tuple_arg_join : internal::view
+{
+  const std::tuple<T...> &tuple;
+  basic_string_view<Char> sep;
+
+  tuple_arg_join(const std::tuple<T...> &t, basic_string_view<Char> s) : tuple{t}, sep{s} {}
+};
+
+template <typename Char, typename... T> struct formatter<tuple_arg_join<Char, T...>, Char>
+{
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(const tuple_arg_join<Char, T...> &value,
+                                          FormatContext &                   ctx)
+  {
+    return format(value, ctx, internal::make_index_sequence<sizeof...(T)>{});
+  }
+
+private:
+  template <typename FormatContext, size_t... N>
+  typename FormatContext::iterator format(const tuple_arg_join<Char, T...> &value,
+                                          FormatContext &ctx, internal::index_sequence<N...>)
+  {
+    return format_args(value, ctx, std::get<N>(value.tuple)...);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format_args(const tuple_arg_join<Char, T...> &,
+                                               FormatContext &ctx)
+  {
+    // NOTE: for compilers that support C++17, this empty function instantiation
+    // can be replaced with a constexpr branch in the variadic overload.
+    return ctx.out();
+  }
+
+  template <typename FormatContext, typename Arg, typename... Args>
+  typename FormatContext::iterator format_args(const tuple_arg_join<Char, T...> &value,
+                                               FormatContext &ctx, const Arg &arg,
+                                               const Args &... args)
+  {
+    using base = formatter<typename std::decay<Arg>::type, Char>;
+    auto out   = ctx.out();
+    out        = base{}.format(arg, ctx);
+    if (sizeof...(Args) > 0) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return format_args(value, ctx, args...);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<char, T...> join(const std::tuple<T...> &tuple, string_view sep)
+{
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<wchar_t, T...> join(const std::tuple<T...> &tuple, wstring_view sep)
+{
+  return {tuple, sep};
+}
+
 FMT_END_NAMESPACE
 
-#endif  // FMT_RANGES_H_
+#endif // FMT_RANGES_H_
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/safe-duration-cast.h b/packages/seacas/libraries/suplib_cpp/fmt/safe-duration-cast.h
index aa036182964f..d97b466b1509 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/safe-duration-cast.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/safe-duration-cast.h
@@ -20,92 +20,95 @@ FMT_BEGIN_NAMESPACE
 
 namespace safe_duration_cast {
 
-template <typename To, typename From,
-          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
-                        std::numeric_limits<From>::is_signed ==
-                            std::numeric_limits<To>::is_signed)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
-  ec = 0;
-  using F = std::numeric_limits<From>;
-  using T = std::numeric_limits<To>;
-  static_assert(F::is_integer, "From must be integral");
-  static_assert(T::is_integer, "To must be integral");
-
-  // A and B are both signed, or both unsigned.
-  if (F::digits <= T::digits) {
-    // From fits in To without any problem.
-  } else {
-    // From does not always fit in To, resort to a dynamic check.
-    if (from < T::min() || from > T::max()) {
-      // outside range.
-      ec = 1;
-      return {};
-    }
-  }
-  return static_cast<To>(from);
-}
-
-/**
- * converts From to To, without loss. If the dynamic value of from
- * can't be converted to To without loss, ec is set.
- */
-template <typename To, typename From,
-          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
-                        std::numeric_limits<From>::is_signed !=
-                            std::numeric_limits<To>::is_signed)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
-  ec = 0;
-  using F = std::numeric_limits<From>;
-  using T = std::numeric_limits<To>;
-  static_assert(F::is_integer, "From must be integral");
-  static_assert(T::is_integer, "To must be integral");
-
-  if (F::is_signed && !T::is_signed) {
-    // From may be negative, not allowed!
-    if (from < 0) {
-      ec = 1;
-      return {};
-    }
-
-    // From is positive. Can it always fit in To?
+  template <typename To, typename From,
+            FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed ==
+                                                                std::numeric_limits<To>::is_signed)>
+  FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+  {
+    ec      = 0;
+    using F = std::numeric_limits<From>;
+    using T = std::numeric_limits<To>;
+    static_assert(F::is_integer, "From must be integral");
+    static_assert(T::is_integer, "To must be integral");
+
+    // A and B are both signed, or both unsigned.
     if (F::digits <= T::digits) {
-      // yes, From always fits in To.
-    } else {
-      // from may not fit in To, we have to do a dynamic check
-      if (from > static_cast<From>(T::max())) {
+      // From fits in To without any problem.
+    }
+    else {
+      // From does not always fit in To, resort to a dynamic check.
+      if (from < T::min() || from > T::max()) {
+        // outside range.
         ec = 1;
         return {};
       }
     }
+    return static_cast<To>(from);
   }
 
-  if (!F::is_signed && T::is_signed) {
-    // can from be held in To?
-    if (F::digits < T::digits) {
-      // yes, From always fits in To.
-    } else {
-      // from may not fit in To, we have to do a dynamic check
-      if (from > static_cast<From>(T::max())) {
-        // outside range.
+  /**
+   * converts From to To, without loss. If the dynamic value of from
+   * can't be converted to To without loss, ec is set.
+   */
+  template <typename To, typename From,
+            FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed !=
+                                                                std::numeric_limits<To>::is_signed)>
+  FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+  {
+    ec      = 0;
+    using F = std::numeric_limits<From>;
+    using T = std::numeric_limits<To>;
+    static_assert(F::is_integer, "From must be integral");
+    static_assert(T::is_integer, "To must be integral");
+
+    if (F::is_signed && !T::is_signed) {
+      // From may be negative, not allowed!
+      if (fmt::internal::is_negative(from)) {
         ec = 1;
         return {};
       }
+
+      // From is positive. Can it always fit in To?
+      if (F::digits <= T::digits) {
+        // yes, From always fits in To.
+      }
+      else {
+        // from may not fit in To, we have to do a dynamic check
+        if (from > static_cast<From>(T::max())) {
+          ec = 1;
+          return {};
+        }
+      }
+    }
+
+    if (!F::is_signed && T::is_signed) {
+      // can from be held in To?
+      if (F::digits < T::digits) {
+        // yes, From always fits in To.
+      }
+      else {
+        // from may not fit in To, we have to do a dynamic check
+        if (from > static_cast<From>(T::max())) {
+          // outside range.
+          ec = 1;
+          return {};
+        }
+      }
     }
-  }
 
-  // reaching here means all is ok for lossless conversion.
-  return static_cast<To>(from);
+    // reaching here means all is ok for lossless conversion.
+    return static_cast<To>(from);
 
-}  // function
+  } // function
 
-template <typename To, typename From,
-          FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
-  ec = 0;
-  return from;
-}  // function
+  template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)>
+  FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+  {
+    ec = 0;
+    return from;
+  } // function
 
-// clang-format off
+  // clang-format off
 /**
  * converts From to To if possible, otherwise ec is set.
  *
@@ -118,176 +121,174 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
  * subnormal                        | best effort
  * -Inf                             | -Inf
  */
-// clang-format on
-template <typename To, typename From,
-          FMT_ENABLE_IF(!std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
-  ec = 0;
-  using T = std::numeric_limits<To>;
-  static_assert(std::is_floating_point<From>::value, "From must be floating");
-  static_assert(std::is_floating_point<To>::value, "To must be floating");
-
-  // catch the only happy case
-  if (std::isfinite(from)) {
-    if (from >= T::lowest() && from <= T::max()) {
-      return static_cast<To>(from);
+  // clang-format on
+  template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value)>
+  FMT_CONSTEXPR To safe_float_conversion(const From from, int &ec)
+  {
+    ec      = 0;
+    using T = std::numeric_limits<To>;
+    static_assert(std::is_floating_point<From>::value, "From must be floating");
+    static_assert(std::is_floating_point<To>::value, "To must be floating");
+
+    // catch the only happy case
+    if (std::isfinite(from)) {
+      if (from >= T::lowest() && from <= T::max()) {
+        return static_cast<To>(from);
+      }
+      // not within range.
+      ec = 1;
+      return {};
     }
-    // not within range.
-    ec = 1;
-    return {};
-  }
 
-  // nan and inf will be preserved
-  return static_cast<To>(from);
-}  // function
+    // nan and inf will be preserved
+    return static_cast<To>(from);
+  } // function
 
-template <typename To, typename From,
-          FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
-  ec = 0;
-  static_assert(std::is_floating_point<From>::value, "From must be floating");
-  return from;
-}
-
-/**
- * safe duration cast between integral durations
- */
-template <typename To, typename FromRep, typename FromPeriod,
-          FMT_ENABLE_IF(std::is_integral<FromRep>::value),
-          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
-To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                      int& ec) {
-  using From = std::chrono::duration<FromRep, FromPeriod>;
-  ec = 0;
-  // the basic idea is that we need to convert from count() in the from type
-  // to count() in the To type, by multiplying it with this:
-  using Factor = std::ratio_divide<typename From::period, typename To::period>;
-
-  static_assert(Factor::num > 0, "num must be positive");
-  static_assert(Factor::den > 0, "den must be positive");
-
-  // the conversion is like this: multiply from.count() with Factor::num
-  // /Factor::den and convert it to To::rep, all this without
-  // overflow/underflow. let's start by finding a suitable type that can hold
-  // both To, From and Factor::num
-  using IntermediateRep =
-      typename std::common_type<typename From::rep, typename To::rep,
-                                decltype(Factor::num)>::type;
-
-  // safe conversion to IntermediateRep
-  IntermediateRep count =
-      lossless_integral_conversion<IntermediateRep>(from.count(), ec);
-  if (ec) {
-    return {};
+  template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)>
+  FMT_CONSTEXPR To safe_float_conversion(const From from, int &ec)
+  {
+    ec = 0;
+    static_assert(std::is_floating_point<From>::value, "From must be floating");
+    return from;
   }
-  // multiply with Factor::num without overflow or underflow
-  if (Factor::num != 1) {
-    constexpr auto max1 =
-        std::numeric_limits<IntermediateRep>::max() / Factor::num;
-    if (count > max1) {
-      ec = 1;
+
+  /**
+   * safe duration cast between integral durations
+   */
+  template <typename To, typename FromRep, typename FromPeriod,
+            FMT_ENABLE_IF(std::is_integral<FromRep>::value),
+            FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
+  To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int &ec)
+  {
+    using From = std::chrono::duration<FromRep, FromPeriod>;
+    ec         = 0;
+    // the basic idea is that we need to convert from count() in the from type
+    // to count() in the To type, by multiplying it with this:
+    struct Factor : std::ratio_divide<typename From::period, typename To::period>
+    {
+    };
+
+    static_assert(Factor::num > 0, "num must be positive");
+    static_assert(Factor::den > 0, "den must be positive");
+
+    // the conversion is like this: multiply from.count() with Factor::num
+    // /Factor::den and convert it to To::rep, all this without
+    // overflow/underflow. let's start by finding a suitable type that can hold
+    // both To, From and Factor::num
+    using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep,
+                                                      decltype(Factor::num)>::type;
+
+    // safe conversion to IntermediateRep
+    IntermediateRep count = lossless_integral_conversion<IntermediateRep>(from.count(), ec);
+    if (ec) {
       return {};
     }
-    constexpr auto min1 =
-        std::numeric_limits<IntermediateRep>::min() / Factor::num;
-    if (count < min1) {
-      ec = 1;
-      return {};
+    // multiply with Factor::num without overflow or underflow
+    if (Factor::num != 1) {
+      const auto max1 = internal::max_value<IntermediateRep>() / Factor::num;
+      if (count > max1) {
+        ec = 1;
+        return {};
+      }
+      const auto min1 = std::numeric_limits<IntermediateRep>::min() / Factor::num;
+      if (count < min1) {
+        ec = 1;
+        return {};
+      }
+      count *= Factor::num;
     }
-    count *= Factor::num;
-  }
-
-  // this can't go wrong, right? den>0 is checked earlier.
-  if (Factor::den != 1) {
-    count /= Factor::den;
-  }
-  // convert to the to type, safely
-  using ToRep = typename To::rep;
-  const ToRep tocount = lossless_integral_conversion<ToRep>(count, ec);
-  if (ec) {
-    return {};
-  }
-  return To{tocount};
-}
 
-/**
- * safe duration_cast between floating point durations
- */
-template <typename To, typename FromRep, typename FromPeriod,
-          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
-          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
-To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                      int& ec) {
-  using From = std::chrono::duration<FromRep, FromPeriod>;
-  ec = 0;
-  if (std::isnan(from.count())) {
-    // nan in, gives nan out. easy.
-    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+    // this can't go wrong, right? den>0 is checked earlier.
+    if (Factor::den != 1) {
+      count /= Factor::den;
+    }
+    // convert to the to type, safely
+    using ToRep         = typename To::rep;
+    const ToRep tocount = lossless_integral_conversion<ToRep>(count, ec);
+    if (ec) {
+      return {};
+    }
+    return To{tocount};
   }
-  // maybe we should also check if from is denormal, and decide what to do about
-  // it.
 
-  // +-inf should be preserved.
-  if (std::isinf(from.count())) {
-    return To{from.count()};
-  }
+  /**
+   * safe duration_cast between floating point durations
+   */
+  template <typename To, typename FromRep, typename FromPeriod,
+            FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
+            FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
+  To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int &ec)
+  {
+    using From = std::chrono::duration<FromRep, FromPeriod>;
+    ec         = 0;
+    if (std::isnan(from.count())) {
+      // nan in, gives nan out. easy.
+      return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+    }
+    // maybe we should also check if from is denormal, and decide what to do about
+    // it.
 
-  // the basic idea is that we need to convert from count() in the from type
-  // to count() in the To type, by multiplying it with this:
-  using Factor = std::ratio_divide<typename From::period, typename To::period>;
-
-  static_assert(Factor::num > 0, "num must be positive");
-  static_assert(Factor::den > 0, "den must be positive");
-
-  // the conversion is like this: multiply from.count() with Factor::num
-  // /Factor::den and convert it to To::rep, all this without
-  // overflow/underflow. let's start by finding a suitable type that can hold
-  // both To, From and Factor::num
-  using IntermediateRep =
-      typename std::common_type<typename From::rep, typename To::rep,
-                                decltype(Factor::num)>::type;
-
-  // force conversion of From::rep -> IntermediateRep to be safe,
-  // even if it will never happen be narrowing in this context.
-  IntermediateRep count =
-      safe_float_conversion<IntermediateRep>(from.count(), ec);
-  if (ec) {
-    return {};
-  }
+    // +-inf should be preserved.
+    if (std::isinf(from.count())) {
+      return To{from.count()};
+    }
 
-  // multiply with Factor::num without overflow or underflow
-  if (Factor::num != 1) {
-    constexpr auto max1 = std::numeric_limits<IntermediateRep>::max() /
-                          static_cast<IntermediateRep>(Factor::num);
-    if (count > max1) {
-      ec = 1;
+    // the basic idea is that we need to convert from count() in the from type
+    // to count() in the To type, by multiplying it with this:
+    struct Factor : std::ratio_divide<typename From::period, typename To::period>
+    {
+    };
+
+    static_assert(Factor::num > 0, "num must be positive");
+    static_assert(Factor::den > 0, "den must be positive");
+
+    // the conversion is like this: multiply from.count() with Factor::num
+    // /Factor::den and convert it to To::rep, all this without
+    // overflow/underflow. let's start by finding a suitable type that can hold
+    // both To, From and Factor::num
+    using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep,
+                                                      decltype(Factor::num)>::type;
+
+    // force conversion of From::rep -> IntermediateRep to be safe,
+    // even if it will never happen be narrowing in this context.
+    IntermediateRep count = safe_float_conversion<IntermediateRep>(from.count(), ec);
+    if (ec) {
       return {};
     }
-    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
-                          static_cast<IntermediateRep>(Factor::num);
-    if (count < min1) {
-      ec = 1;
-      return {};
+
+    // multiply with Factor::num without overflow or underflow
+    if (Factor::num != 1) {
+      constexpr auto max1 =
+          internal::max_value<IntermediateRep>() / static_cast<IntermediateRep>(Factor::num);
+      if (count > max1) {
+        ec = 1;
+        return {};
+      }
+      constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
+                            static_cast<IntermediateRep>(Factor::num);
+      if (count < min1) {
+        ec = 1;
+        return {};
+      }
+      count *= static_cast<IntermediateRep>(Factor::num);
     }
-    count *= static_cast<IntermediateRep>(Factor::num);
-  }
 
-  // this can't go wrong, right? den>0 is checked earlier.
-  if (Factor::den != 1) {
-    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
-    count /= static_cast<common_t>(Factor::den);
-  }
+    // this can't go wrong, right? den>0 is checked earlier.
+    if (Factor::den != 1) {
+      using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
+      count /= static_cast<common_t>(Factor::den);
+    }
 
-  // convert to the to type, safely
-  using ToRep = typename To::rep;
+    // convert to the to type, safely
+    using ToRep = typename To::rep;
 
-  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
-  if (ec) {
-    return {};
+    const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
+    if (ec) {
+      return {};
+    }
+    return To{tocount};
   }
-  return To{tocount};
-}
 
-}  // namespace safe_duration_cast
+} // namespace safe_duration_cast
 
 FMT_END_NAMESPACE
diff --git a/packages/seacas/scripts/exodus3.in.py b/packages/seacas/scripts/exodus3.in.py
index 8a6115c205e7..c7f5428a32b9 100755
--- a/packages/seacas/scripts/exodus3.in.py
+++ b/packages/seacas/scripts/exodus3.in.py
@@ -1,5 +1,5 @@
 """
-exodus.py v 1.16 (seacas-beta) is a python wrapper of some of the exodus library
+exodus.py v 1.17 (seacas-beta) is a python wrapper of some of the exodus library
 (Python 3 Version)
 
 Exodus is a common database for multiple application codes (mesh
@@ -5362,7 +5362,7 @@ def copy_mesh(fromFileName, toFileName, exoFromObj=None,
     # If the user did not supply a exodus object to copy from, attempt to read an
     # exodus database with the name "fromFileName"
     if exoFromObj is None:
-        exoFrom = exodus(fromFileName.encode('ascii'), "r", array_type=array_type)
+        exoFrom = exodus(fromFileName, "r", array_type=array_type)
     else:
         exoFrom = exoFromObj
 
diff --git a/packages/seacas/scripts/exomerge2.py b/packages/seacas/scripts/exomerge2.py
index eb68d88f6498..da8975edc629 100755
--- a/packages/seacas/scripts/exomerge2.py
+++ b/packages/seacas/scripts/exomerge2.py
@@ -445,7 +445,7 @@ def __getattr__(self, name):
             trial = name + 's'
             if trial in names:
                 return getattr(self, trial)
-        # if the name appears to be plural, seach for the singular version
+        # if the name appears to be plural, search for the singular version
         if name.endswith('s'):
             trial = name[:-1]
             if not trial.endswith('s') and trial in names:
@@ -1956,7 +1956,7 @@ def export(self, filename, *args, **kwargs):
         exporters[extension](filename, *args, **kwargs)
 
     def _error_evaluating_expression(self, expression, var):
-        """Throw an error saying we could not evalute the given expression."""
+        """Throw an error saying we could not evaluate the given expression."""
         self._error('Invalid expression',
                     'An error occurred while trying to evaluate the given '
                     'expression.  It is likely that this expression is '
@@ -3175,7 +3175,7 @@ def get_side_set_field_values(self,
                                   side_set_id='auto',
                                   timestep='last'):
         """
-        Return the list of side set field vlaues.
+        Return the list of side set field values.
 
         The actual list of values is returned, so any modifications to it will
         be stored in the model.
@@ -4293,7 +4293,7 @@ def create_side_set_field(self,
         side set field on a particular field, pass in 'side_set_ids'.
 
         To set the value of the field, pass in 'value'.  By default this is
-        0 for displacement fiels and NaN for all other fields.
+        0 for displacement fields and NaN for all other fields.
 
         Example:
         >>> model.create_side_set_field('temperature', 13, 298.15)
@@ -4445,7 +4445,7 @@ def _transform_expression(self, expression):
         transforms.append(('<', '((R) - (L)) - abs((R) - (L))'))
         transforms.append(('==', 'abs((L) - (R))'))
         transforms.append(('=', 'abs((L) - (R))'))
-        # replace occurances of each transform
+        # replace occurrences of each transform
         for separator, transform in transforms:
             while separator in expression:
                 # ensure parenthesis count is identical
@@ -5417,7 +5417,7 @@ def create_averaged_element_field(self,
             if not all_defined:
                 self._warning('Fields not defined.',
                               'Not all of the requested element fields are '
-                              'defined on element block %s.  The everaged '
+                              'defined on element block %s.  The averaged '
                               'field will not be created.' % element_block_id)
                 continue
             # create the field if it doesn't exist
@@ -5477,7 +5477,7 @@ def convert_element_field_to_node_field(self,
         default_value = self._get_default_field_value(node_field_name)
         # process each timestep
         for timestep_index in xrange(len(self.timesteps)):
-            # initialze node field
+            # initialize node field
             node_field_values = [0.0] * len(self.nodes)
             node_field_elements = [0] * len(self.nodes)
             # for each element block
diff --git a/packages/seacas/scripts/exomerge3.py b/packages/seacas/scripts/exomerge3.py
index 58ba60fad21a..32428425c1cd 100644
--- a/packages/seacas/scripts/exomerge3.py
+++ b/packages/seacas/scripts/exomerge3.py
@@ -413,7 +413,7 @@ def __getattr__(self, name):
             trial = name + 's'
             if trial in names:
                 return getattr(self, trial)
-        # if the name appears to be plural, seach for the singular version
+        # if the name appears to be plural, search for the singular version
         if name.endswith('s'):
             trial = name[:-1]
             if not trial.endswith('s') and trial in names:
@@ -706,9 +706,9 @@ def threshold_element_blocks(self,
         element_block_ids = self._format_element_block_id_list(
             element_block_ids)
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         if new_element_block_id is not None:
             if self.element_block_exists(new_element_block_id):
                 self._exists_error(new_element_block_id, 'element block')
@@ -1502,13 +1502,13 @@ def _partition_triangle_block_from_node_field(self, element_block_id,
         [element_block_id] = self._format_element_block_id_list(
             [element_block_id], single=True)
         [node_field_name] = self._format_id_list([node_field_name],
-                                               self.get_node_field_names(),
-                                               'node field',
-                                               single=True)
+                                                 self.get_node_field_names(),
+                                                 'node field',
+                                                 single=True)
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         # verify block is actually a tri3 block
         if self._get_element_type(element_block_id) != 'tri3':
             self._error(
@@ -1665,13 +1665,13 @@ def export_wrl_model(self,
         element_block_ids = self._format_element_block_id_list(
             element_block_ids)
         [node_field_name] = self._format_id_list([node_field_name],
-                                               self.get_node_field_names(),
-                                               'node field',
-                                               single=True)
+                                                 self.get_node_field_names(),
+                                                 'node field',
+                                                 single=True)
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         timestep_index = self.timesteps.index(timestep)
         if displacement_timestep == 'auto':
             if self.displacement_field_exists():
@@ -1912,7 +1912,7 @@ def export(self, filename, *args, **kwargs):
         exporters[extension](filename, *args, **kwargs)
 
     def _error_evaluating_expression(self, expression, var):
-        """Throw an error saying we could not evalute the given expression."""
+        """Throw an error saying we could not evaluate the given expression."""
         self._error(
             'Invalid expression',
             'An error occurred while trying to evaluate the given '
@@ -3099,9 +3099,9 @@ def get_element_field_values(self,
         [element_block_id] = self._format_element_block_id_list(
             [element_block_id], single=True)
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         timestep_index = self._get_internal_timestep_index(timestep)
         if not self.element_field_exists(element_field_name, element_block_id):
             self._missing_on_entity_error(element_field_name, 'element field',
@@ -3114,7 +3114,7 @@ def get_side_set_field_values(self,
                                   side_set_id='auto',
                                   timestep='last'):
         """
-        Return the list of side set field vlaues.
+        Return the list of side set field values.
 
         The actual list of values is returned, so any modifications to it will
         be stored in the model.
@@ -3134,9 +3134,9 @@ def get_side_set_field_values(self,
             'side set field',
             single=True)
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         timestep_index = self._get_internal_timestep_index(timestep)
         if not self.side_set_field_exists(side_set_field_name, side_set_id):
             self._missing_on_entity_error(side_set_field_name,
@@ -3170,9 +3170,9 @@ def get_node_set_field_values(self,
             'node set field',
             single=True)
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         timestep_index = self._get_internal_timestep_index(timestep)
         if not self.node_set_field_exists(node_set_field_name, node_set_id):
             self._missing_on_entity_error(node_set_field_name,
@@ -3342,9 +3342,9 @@ def get_timesteps(self):
     def _get_internal_timestep_index(self, timestep):
         """Return the local timestep index."""
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         return self.timesteps.index(timestep)
 
     def _create_element_field_truth_table(self, element_block_ids,
@@ -3897,9 +3897,9 @@ def _rename_entity(self, entity_type, entity_name, new_entity_name,
                        entity_name_list_function, entity_objects):
         """Rename an entity."""
         [entity_name] = self._format_id_list([entity_name],
-                                           entity_name_list_function(),
-                                           entity_type,
-                                           single=True)
+                                             entity_name_list_function(),
+                                             entity_type,
+                                             single=True)
         if new_entity_name == entity_name:
             return
         if new_entity_name in entity_name_list_function():
@@ -4162,7 +4162,7 @@ def create_side_set_field(self,
         side set field on a particular field, pass in 'side_set_ids'.
 
         To set the value of the field, pass in 'value'.  By default this is
-        0 for displacement fiels and NaN for all other fields.
+        0 for displacement fields and NaN for all other fields.
 
         Example:
         >>> model.create_side_set_field('temperature', 13, 298.15)
@@ -4312,7 +4312,7 @@ def _transform_expression(self, expression):
         transforms.append(('<', '((R) - (L)) - abs((R) - (L))'))
         transforms.append(('==', 'abs((L) - (R))'))
         transforms.append(('=', 'abs((L) - (R))'))
-        # replace occurances of each transform
+        # replace occurrences of each transform
         for separator, transform in transforms:
             while separator in expression:
                 # ensure parenthesis count is identical
@@ -4851,9 +4851,9 @@ def get_node_field_values(self, node_field_name, timestep='last'):
 
         """
         [node_field_name] = self._format_id_list([node_field_name],
-                                               self.get_node_field_names(),
-                                               'node field',
-                                               single=True)
+                                                 self.get_node_field_names(),
+                                                 'node field',
+                                                 single=True)
         timestep_index = self._get_internal_timestep_index(timestep)
         return self.node_fields[node_field_name][timestep_index]
 
@@ -5263,7 +5263,7 @@ def create_averaged_element_field(self,
                 self._warning(
                     'Fields not defined.',
                     'Not all of the requested element fields are '
-                    'defined on element block %s.  The everaged '
+                    'defined on element block %s.  The averaged '
                     'field will not be created.' % element_block_id)
                 continue
             # create the field if it doesn't exist
@@ -5323,7 +5323,7 @@ def convert_element_field_to_node_field(self,
         default_value = self._get_default_field_value(node_field_name)
         # process each timestep
         for timestep_index in range(len(self.timesteps)):
-            # initialze node field
+            # initialize node field
             node_field_values = [0.0] * len(self.nodes)
             node_field_elements = [0] * len(self.nodes)
             # for each element block
@@ -5374,9 +5374,9 @@ def convert_node_field_to_element_field(self,
 
         """
         [node_field_name] = self._format_id_list([node_field_name],
-                                               self.get_node_field_names(),
-                                               'node field',
-                                               single=True)
+                                                 self.get_node_field_names(),
+                                                 'node field',
+                                                 single=True)
         element_block_ids = self._format_element_block_id_list(
             element_block_ids)
         # format the arguments
@@ -5679,7 +5679,7 @@ def get_element_count(self, element_block_ids='all'):
         Return the total number of elements in the given element blocks.
 
         Example:
-        >>> print object.get_element_count()
+        >>> print((' %d elements' % (object.get_element_count())))
 
         """
         element_block_ids = self._format_element_block_id_list(
@@ -6468,9 +6468,9 @@ def copy_timestep(self, timestep, new_timestep):
 
         """
         [timestep] = self._format_id_list([timestep],
-                                        self.get_timesteps(),
-                                        'timestep',
-                                        single=True)
+                                          self.get_timesteps(),
+                                          'timestep',
+                                          single=True)
         if self.timestep_exists(new_timestep):
             self._exists_warning(new_timestep, 'timestep')
             return

From 7989aa050993acdb1e6f670317a7fb3d26a18020 Mon Sep 17 00:00:00 2001
From: Matthias Mayr <mayrmt@users.noreply.github.com>
Date: Tue, 19 Nov 2019 18:23:54 +0100
Subject: [PATCH 03/21] MueLu: fix misleading comments in regionMG unit tests

---
 packages/muelu/test/unit_tests/RegionVector.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/packages/muelu/test/unit_tests/RegionVector.cpp b/packages/muelu/test/unit_tests/RegionVector.cpp
index e7425d6d24d3..180f8617ba0b 100644
--- a/packages/muelu/test/unit_tests/RegionVector.cpp
+++ b/packages/muelu/test/unit_tests/RegionVector.cpp
@@ -266,7 +266,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionVector, RegionCompositeVector, Scalar, L
       }
 
     } else if(numRanks == 4) {
-      // All ranks will have the same number of rows/cols/entries
+      // All ranks will have the same global length of the vector, but local length differs.
+      // Due to region numbering and region interface duplications,
+      // lower rank IDs have more local entries then higher rank IDs.
       if( myRank == 0){
         TEST_EQUALITY(compVec->getLocalLength(),  9);
         TEST_EQUALITY(compVec->getGlobalLength(), 25);
@@ -295,7 +297,7 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionVector, RegionCompositeVector, Scalar, L
       } else if(myRank == 3) {
         refValues.deepCopy(ArrayView<const SC>({4.3, 5.3, 7.3, 8.3}));
       }
-      // Loop over region matrix data and compare it to ref data
+      // Loop over region vector data and compare it to reference data
       myValues = compVec->getData(0);
       for(int idx = 0; idx < compVec->getLocalLength(); ++idx) {
         TEST_FLOATING_EQUALITY(myValues[idx], refValues[idx], 100*TMT::eps());
@@ -357,7 +359,7 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionVector, RegionCompositeVector, Scalar, L
       } else if(myRank == 3) {
         refValues.deepCopy(ArrayView<const SC>({4, 2, 2, 2, 1, 1, 2, 1, 1}));
       }
-      // Loop over region matrix data and compare it to ref data
+      // Loop over region vector data and compare it to reference data
       for (int j = 0; j < maxRegPerProc; j++){
         myScaling = interfaceScaling[j]->getData(0);
         for(int idx = 0; idx < interfaceScaling[j]->getLocalLength(); ++idx) {

From f2ce62a23c9dab33c5aeae04d570989a04a3b973 Mon Sep 17 00:00:00 2001
From: Greg Sjaardema <gdsjaar@sandia.gov>
Date: Tue, 19 Nov 2019 10:43:40 -0700
Subject: [PATCH 04/21] Attempt to fix NVCC / INTEL compiler errors

---
 .../libraries/ioss/src/Ioss_FaceGenerator.h   | 48 +++++++++----------
 packages/seacas/libraries/ioss/src/fmt/core.h |  4 +-
 .../seacas/libraries/suplib_cpp/fmt/core.h    |  4 +-
 3 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h b/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h
index a52320bfccb1..874e0d302c49 100644
--- a/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h
+++ b/packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.h
@@ -89,7 +89,29 @@ namespace Ioss {
     size_t operator()(const Face &face) const { return face.hashId_; }
   };
 
-  struct FaceEqual;
+  struct FaceEqual
+  {
+    bool operator()(const Face &left, const Face &right) const
+    {
+      if (left.hashId_ != right.hashId_) {
+        return false;
+      }
+      // Hash (hashId_) is equal
+      // Check whether same vertices (can be in different order)
+      // Most (All?) of the time, there are no hashId_ collisions, so this test will not
+      // find a difference and the function will return 'true'
+      // However, for some reason, removing this check does not change the execution time
+      // appreiciably...
+      for (auto lvert : left.connectivity_) {
+        if (std::find(right.connectivity_.cbegin(), right.connectivity_.cend(), lvert) ==
+            right.connectivity_.cend()) {
+          // Not found, therefore not the same.
+          return false;
+        }
+      }
+      return true;
+    }
+  };
 
 #if defined USE_STD
   using FaceUnorderedSet = std::unordered_set<Face, FaceHash, FaceEqual>;
@@ -116,30 +138,6 @@ namespace Ioss {
     std::map<std::string, FaceUnorderedSet> faces_;
   };
 
-  struct FaceEqual
-  {
-    bool operator()(const Face &left, const Face &right) const
-    {
-      if (left.hashId_ != right.hashId_) {
-        return false;
-      }
-      // Hash (hashId_) is equal
-      // Check whether same vertices (can be in different order)
-      // Most (All?) of the time, there are no hashId_ collisions, so this test will not
-      // find a difference and the function will return 'true'
-      // However, for some reason, removing this check does not change the execution time
-      // appreiciably...
-      for (auto lvert : left.connectivity_) {
-        if (std::find(right.connectivity_.cbegin(), right.connectivity_.cend(), lvert) ==
-            right.connectivity_.cend()) {
-          // Not found, therefore not the same.
-          return false;
-        }
-      }
-      return true;
-    }
-  };
-
 } // namespace Ioss
 
 #endif
diff --git a/packages/seacas/libraries/ioss/src/fmt/core.h b/packages/seacas/libraries/ioss/src/fmt/core.h
index 1a1ecfe1e83a..d6c9b9bdcab9 100644
--- a/packages/seacas/libraries/ioss/src/fmt/core.h
+++ b/packages/seacas/libraries/ioss/src/fmt/core.h
@@ -241,7 +241,7 @@ namespace internal {
 
 #ifdef FMT_USE_INT128
 // Do nothing.
-#elif defined(__SIZEOF_INT128__)
+#elif defined(__SIZEOF_INT128__) && !defined(FMT_NVCC)
 #define FMT_USE_INT128 1
   using int128_t                                 = __int128_t;
   using uint128_t                                = __uint128_t;
@@ -1426,9 +1426,11 @@ namespace internal {
   inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
   make_args_checked(const S &format_str, const remove_reference_t<Args> &... args)
   {
+#ifndef __INTEL_COMPILER
     static_assert(all_true<(!std::is_base_of<view, remove_reference_t<Args>>() ||
                             !std::is_reference<Args>())...>::value,
                   "passing views as lvalues is disallowed");
+#endif
     check_format_string<remove_const_t<remove_reference_t<Args>>...>(format_str);
     return {args...};
   }
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/core.h b/packages/seacas/libraries/suplib_cpp/fmt/core.h
index 1a1ecfe1e83a..d6c9b9bdcab9 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/core.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/core.h
@@ -241,7 +241,7 @@ namespace internal {
 
 #ifdef FMT_USE_INT128
 // Do nothing.
-#elif defined(__SIZEOF_INT128__)
+#elif defined(__SIZEOF_INT128__) && !defined(FMT_NVCC)
 #define FMT_USE_INT128 1
   using int128_t                                 = __int128_t;
   using uint128_t                                = __uint128_t;
@@ -1426,9 +1426,11 @@ namespace internal {
   inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
   make_args_checked(const S &format_str, const remove_reference_t<Args> &... args)
   {
+#ifndef __INTEL_COMPILER
     static_assert(all_true<(!std::is_base_of<view, remove_reference_t<Args>>() ||
                             !std::is_reference<Args>())...>::value,
                   "passing views as lvalues is disallowed");
+#endif
     check_format_string<remove_const_t<remove_reference_t<Args>>...>(format_str);
     return {args...};
   }

From e0a46093f2f28e133d86da7594337f195485dc10 Mon Sep 17 00:00:00 2001
From: Greg Sjaardema <gdsjaar@sandia.gov>
Date: Tue, 19 Nov 2019 13:18:55 -0700
Subject: [PATCH 05/21] SEACAS: Attempt to fix CUDA compile errors

---
 packages/seacas/libraries/ioss/src/fmt/format-inl.h   | 4 ++--
 packages/seacas/libraries/suplib_cpp/fmt/format-inl.h | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/seacas/libraries/ioss/src/fmt/format-inl.h b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
index 283d6912e12f..e79f259eeefd 100644
--- a/packages/seacas/libraries/ioss/src/fmt/format-inl.h
+++ b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
@@ -373,13 +373,13 @@ namespace internal {
     template <int SHIFT> friend fp normalize(fp value)
     {
       // Handle subnormals.
-      const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
+      const auto shifted_implicit_bit = implicit_bit << SHIFT;
       while ((value.f & shifted_implicit_bit) == 0) {
         value.f <<= 1;
         --value.e;
       }
       // Subtract 1 to account for hidden bit.
-      const auto offset = fp::significand_size - fp::double_significand_size - SHIFT - 1;
+      const auto offset = significand_size - double_significand_size - SHIFT - 1;
       value.f <<= offset;
       value.e -= offset;
       return value;
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
index 283d6912e12f..e79f259eeefd 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
@@ -373,13 +373,13 @@ namespace internal {
     template <int SHIFT> friend fp normalize(fp value)
     {
       // Handle subnormals.
-      const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
+      const auto shifted_implicit_bit = implicit_bit << SHIFT;
       while ((value.f & shifted_implicit_bit) == 0) {
         value.f <<= 1;
         --value.e;
       }
       // Subtract 1 to account for hidden bit.
-      const auto offset = fp::significand_size - fp::double_significand_size - SHIFT - 1;
+      const auto offset = significand_size - double_significand_size - SHIFT - 1;
       value.f <<= offset;
       value.e -= offset;
       return value;

From 3359b2da01af6b4a953682c12e4bf2cf7ca49913 Mon Sep 17 00:00:00 2001
From: Matthias Mayr <matthias.mayr@unibw.de>
Date: Wed, 20 Nov 2019 08:51:19 +0100
Subject: [PATCH 06/21] MueLu: remove debug output from regionMG unit test

---
 packages/muelu/test/unit_tests/RegionVector.cpp | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/packages/muelu/test/unit_tests/RegionVector.cpp b/packages/muelu/test/unit_tests/RegionVector.cpp
index 180f8617ba0b..46363952842e 100644
--- a/packages/muelu/test/unit_tests/RegionVector.cpp
+++ b/packages/muelu/test/unit_tests/RegionVector.cpp
@@ -166,13 +166,6 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionVector, RegionCompositeVector, Scalar, L
 
     compositeToRegional(compVec, quasiRegVec, regVec, maxRegPerProc, rowMapPerGrp, revisedRowMapPerGrp, rowImportPerGrp);
 
-    //RCP<Teuchos::FancyOStream> outF = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
-    //std::cout<<"compVec:"<<std::endl;
-    //compVec->describe(*outF, Teuchos::VERB_EXTREME);
-    //std::cout<<"Quasi:"<<std::endl;
-    //quasiRegVec[0]->describe(*outF, Teuchos::VERB_EXTREME);
-    //std::cout<<"Reg:"<<std::endl;
-    //regVec[0]->describe(*outF, Teuchos::VERB_EXTREME);
     if(numRanks == 1){
       TEST_EQUALITY(regVec[0]->getLocalLength(),  25);
       TEST_EQUALITY(regVec[0]->getGlobalLength(), 25);

From 6b17033fc78721b84baaa83212b499ce6a8584aa Mon Sep 17 00:00:00 2001
From: Matthias Mayr <matthias.mayr@unibw.de>
Date: Wed, 20 Nov 2019 09:17:17 +0100
Subject: [PATCH 07/21] MueLu: fix type handling in regionMG unit test

---
 packages/muelu/test/unit_tests/RegionVector.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/muelu/test/unit_tests/RegionVector.cpp b/packages/muelu/test/unit_tests/RegionVector.cpp
index 46363952842e..f88795063c29 100644
--- a/packages/muelu/test/unit_tests/RegionVector.cpp
+++ b/packages/muelu/test/unit_tests/RegionVector.cpp
@@ -157,7 +157,7 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionVector, RegionCompositeVector, Scalar, L
     compVec->putScalar(0.0);
     const size_t localLength = compVec->getLocalLength();
     for (size_t k = 0; k < localLength; ++k) {
-      compVec->replaceLocalValue(k, k + myRank/10.0);// (LO, Scalar) need to fix type of k
+      compVec->replaceLocalValue(k, static_cast<Scalar>(k));
     }
 
     // Create a region vector

From d08e031352e6fc0018dd77913f8065b80aed45c8 Mon Sep 17 00:00:00 2001
From: Greg Sjaardema <gdsjaar@sandia.gov>
Date: Wed, 20 Nov 2019 09:17:26 -0700
Subject: [PATCH 08/21] SEACAS: Another try at fixing nvcc build

---
 packages/seacas/libraries/ioss/src/fmt/core.h         | 5 ++---
 packages/seacas/libraries/ioss/src/fmt/format-inl.h   | 4 ++--
 packages/seacas/libraries/suplib_cpp/fmt/core.h       | 5 ++---
 packages/seacas/libraries/suplib_cpp/fmt/format-inl.h | 4 ++--
 4 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/packages/seacas/libraries/ioss/src/fmt/core.h b/packages/seacas/libraries/ioss/src/fmt/core.h
index d6c9b9bdcab9..2ae55c223154 100644
--- a/packages/seacas/libraries/ioss/src/fmt/core.h
+++ b/packages/seacas/libraries/ioss/src/fmt/core.h
@@ -69,8 +69,7 @@
 #ifndef FMT_USE_CONSTEXPR
 #define FMT_USE_CONSTEXPR                                                                          \
   (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 ||                                \
-   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&                                          \
-      !FMT_NVCC
+   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
 #endif
 #if FMT_USE_CONSTEXPR
 #define FMT_CONSTEXPR constexpr
@@ -241,7 +240,7 @@ namespace internal {
 
 #ifdef FMT_USE_INT128
 // Do nothing.
-#elif defined(__SIZEOF_INT128__) && !defined(FMT_NVCC)
+#elif defined(__SIZEOF_INT128__) && !FMT_NVCC
 #define FMT_USE_INT128 1
   using int128_t                                 = __int128_t;
   using uint128_t                                = __uint128_t;
diff --git a/packages/seacas/libraries/ioss/src/fmt/format-inl.h b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
index e79f259eeefd..283d6912e12f 100644
--- a/packages/seacas/libraries/ioss/src/fmt/format-inl.h
+++ b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
@@ -373,13 +373,13 @@ namespace internal {
     template <int SHIFT> friend fp normalize(fp value)
     {
       // Handle subnormals.
-      const auto shifted_implicit_bit = implicit_bit << SHIFT;
+      const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
       while ((value.f & shifted_implicit_bit) == 0) {
         value.f <<= 1;
         --value.e;
       }
       // Subtract 1 to account for hidden bit.
-      const auto offset = significand_size - double_significand_size - SHIFT - 1;
+      const auto offset = fp::significand_size - fp::double_significand_size - SHIFT - 1;
       value.f <<= offset;
       value.e -= offset;
       return value;
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/core.h b/packages/seacas/libraries/suplib_cpp/fmt/core.h
index d6c9b9bdcab9..2ae55c223154 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/core.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/core.h
@@ -69,8 +69,7 @@
 #ifndef FMT_USE_CONSTEXPR
 #define FMT_USE_CONSTEXPR                                                                          \
   (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 ||                                \
-   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&                                          \
-      !FMT_NVCC
+   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
 #endif
 #if FMT_USE_CONSTEXPR
 #define FMT_CONSTEXPR constexpr
@@ -241,7 +240,7 @@ namespace internal {
 
 #ifdef FMT_USE_INT128
 // Do nothing.
-#elif defined(__SIZEOF_INT128__) && !defined(FMT_NVCC)
+#elif defined(__SIZEOF_INT128__) && !FMT_NVCC
 #define FMT_USE_INT128 1
   using int128_t                                 = __int128_t;
   using uint128_t                                = __uint128_t;
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
index e79f259eeefd..283d6912e12f 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
@@ -373,13 +373,13 @@ namespace internal {
     template <int SHIFT> friend fp normalize(fp value)
     {
       // Handle subnormals.
-      const auto shifted_implicit_bit = implicit_bit << SHIFT;
+      const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
       while ((value.f & shifted_implicit_bit) == 0) {
         value.f <<= 1;
         --value.e;
       }
       // Subtract 1 to account for hidden bit.
-      const auto offset = significand_size - double_significand_size - SHIFT - 1;
+      const auto offset = fp::significand_size - fp::double_significand_size - SHIFT - 1;
       value.f <<= offset;
       value.e -= offset;
       return value;

From be8890aa7a9d9c8ec33f0901e5de9ad58d001630 Mon Sep 17 00:00:00 2001
From: Nate Roberts <nvrober@sandia.gov>
Date: Wed, 20 Nov 2019 09:52:29 -0700
Subject: [PATCH 09/21] Intrepid2: fixing issues with hierarchical parallelism
 policies, revealed when Trilinos is built with
 KOKKOS_ENABLE_DEPRECATED_CODE=OFF. (#6310)

Specifically, replaced teamSize in policy constructor with Kokkos::AUTO() in several places.
---
 .../src/Discretization/Basis/Intrepid2_TensorBasis.hpp   | 9 +++------
 .../Basis/HierarchicalBases/TensorViewFunctorTests.cpp   | 3 +--
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/packages/intrepid2/src/Discretization/Basis/Intrepid2_TensorBasis.hpp b/packages/intrepid2/src/Discretization/Basis/Intrepid2_TensorBasis.hpp
index d91d32cb2bdd..09599e3d4c63 100644
--- a/packages/intrepid2/src/Discretization/Basis/Intrepid2_TensorBasis.hpp
+++ b/packages/intrepid2/src/Discretization/Basis/Intrepid2_TensorBasis.hpp
@@ -686,9 +686,8 @@ namespace Intrepid2
             const int outputVectorSize = getVectorSizeForHierarchicalParallelism<OutputValueType>();
             const int pointVectorSize  = getVectorSizeForHierarchicalParallelism<PointValueType>();
             const int vectorSize = std::max(outputVectorSize,pointVectorSize);
-            const int teamSize = basisCardinality2;
             
-            auto policy = Kokkos::TeamPolicy<ExecutionSpace>(basisCardinality1,teamSize,vectorSize);
+            auto policy = Kokkos::TeamPolicy<ExecutionSpace>(basisCardinality1,Kokkos::AUTO(),vectorSize);
             
             double weight = 1.0;
             using FunctorType = TensorViewFunctor<ExecutionSpace, OutputValueType, OutputViewType>;
@@ -840,9 +839,8 @@ namespace Intrepid2
       const int outputVectorSize = getVectorSizeForHierarchicalParallelism<OutputValueType>();
       const int pointVectorSize  = getVectorSizeForHierarchicalParallelism<PointValueType>();
       const int vectorSize = std::max(outputVectorSize,pointVectorSize);
-      const int teamSize = basisCardinality2;
       
-      auto policy = Kokkos::TeamPolicy<ExecutionSpace>(basisCardinality1,teamSize,vectorSize);
+      auto policy = Kokkos::TeamPolicy<ExecutionSpace>(basisCardinality1,Kokkos::AUTO(),vectorSize);
       
       using FunctorType = TensorViewFunctor<ExecutionSpace, OutputValueType, OutputViewType>;
       
@@ -1342,9 +1340,8 @@ namespace Intrepid2
       const int outputVectorSize = getVectorSizeForHierarchicalParallelism<OutputScalar>();
       const int pointVectorSize  = getVectorSizeForHierarchicalParallelism<PointScalar>();
       const int vectorSize = std::max(outputVectorSize,pointVectorSize);
-      const int teamSize = basisCardinality2;
       
-      auto policy = Kokkos::TeamPolicy<ExecutionSpace>(basisCardinality1,teamSize,vectorSize);
+      auto policy = Kokkos::TeamPolicy<ExecutionSpace>(basisCardinality1,Kokkos::AUTO(),vectorSize);
       
       using FunctorType = TensorBasis3_Functor<ExecutionSpace, OutputScalar, OutputViewType>;
       FunctorType functor(outputValues, outputValues1, outputValues2, outputValues3, tensorPoints, weight);
diff --git a/packages/intrepid2/unit-test/Discretization/Basis/HierarchicalBases/TensorViewFunctorTests.cpp b/packages/intrepid2/unit-test/Discretization/Basis/HierarchicalBases/TensorViewFunctorTests.cpp
index 8d75a1eb05b4..d350e9d6ac84 100644
--- a/packages/intrepid2/unit-test/Discretization/Basis/HierarchicalBases/TensorViewFunctorTests.cpp
+++ b/packages/intrepid2/unit-test/Discretization/Basis/HierarchicalBases/TensorViewFunctorTests.cpp
@@ -71,9 +71,8 @@ namespace
     
     const bool hasADType = false;
     const int vectorSize = hasADType ? FAD_VECTOR_SIZE : VECTOR_SIZE;
-    const int teamSize = view2.extent_int(0);
     
-    auto policy = Kokkos::TeamPolicy<ExecutionSpace>(view1.extent_int(0),teamSize,vectorSize);
+    auto policy = Kokkos::TeamPolicy<ExecutionSpace>(view1.extent_int(0),Kokkos::AUTO(),vectorSize);
     
     using FunctorType = TensorViewFunctor<ExecutionSpace, Scalar, ScalarViewType>;
     

From 417e2ebef09041f8ccd6effb9c9f4141ce0302c9 Mon Sep 17 00:00:00 2001
From: Greg Sjaardema <gdsjaar@sandia.gov>
Date: Wed, 20 Nov 2019 14:37:50 -0700
Subject: [PATCH 10/21] SEACAS: kluge to get new lib::fmt maybe working with
 nvcc

---
 .../seacas/libraries/ioss/src/fmt/format-inl.h | 18 ++++++++++++++++++
 .../libraries/suplib_cpp/fmt/format-inl.h      | 18 ++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/packages/seacas/libraries/ioss/src/fmt/format-inl.h b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
index 283d6912e12f..bd6c6bfdde95 100644
--- a/packages/seacas/libraries/ioss/src/fmt/format-inl.h
+++ b/packages/seacas/libraries/ioss/src/fmt/format-inl.h
@@ -372,6 +372,23 @@ namespace internal {
     // Normalizes the value converted from double and multiplied by (1 << SHIFT).
     template <int SHIFT> friend fp normalize(fp value)
     {
+#ifdef __NVCC__
+      static const int double_significand_size = std::numeric_limits<double>::digits - 1;
+      static const uint64_t implicit_bit = 1ull << double_significand_size;
+      static const int significand_size = bits<uint64_t>::value;
+
+      // Handle subnormals.
+      const auto shifted_implicit_bit = implicit_bit << SHIFT;
+      while ((value.f & shifted_implicit_bit) == 0) {
+        value.f <<= 1;
+        --value.e;
+      }
+      // Subtract 1 to account for hidden bit.
+      const auto offset = significand_size - double_significand_size - SHIFT - 1;
+      value.f <<= offset;
+      value.e -= offset;
+      return value;
+#else
       // Handle subnormals.
       const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
       while ((value.f & shifted_implicit_bit) == 0) {
@@ -383,6 +400,7 @@ namespace internal {
       value.f <<= offset;
       value.e -= offset;
       return value;
+#endif
     }
 
     // Assigns d to this and return true iff predecessor is closer than successor.
diff --git a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
index 283d6912e12f..bd6c6bfdde95 100644
--- a/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
+++ b/packages/seacas/libraries/suplib_cpp/fmt/format-inl.h
@@ -372,6 +372,23 @@ namespace internal {
     // Normalizes the value converted from double and multiplied by (1 << SHIFT).
     template <int SHIFT> friend fp normalize(fp value)
     {
+#ifdef __NVCC__
+      static const int double_significand_size = std::numeric_limits<double>::digits - 1;
+      static const uint64_t implicit_bit = 1ull << double_significand_size;
+      static const int significand_size = bits<uint64_t>::value;
+
+      // Handle subnormals.
+      const auto shifted_implicit_bit = implicit_bit << SHIFT;
+      while ((value.f & shifted_implicit_bit) == 0) {
+        value.f <<= 1;
+        --value.e;
+      }
+      // Subtract 1 to account for hidden bit.
+      const auto offset = significand_size - double_significand_size - SHIFT - 1;
+      value.f <<= offset;
+      value.e -= offset;
+      return value;
+#else
       // Handle subnormals.
       const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
       while ((value.f & shifted_implicit_bit) == 0) {
@@ -383,6 +400,7 @@ namespace internal {
       value.f <<= offset;
       value.e -= offset;
       return value;
+#endif
     }
 
     // Assigns d to this and return true iff predecessor is closer than successor.

From 7e76a726a14a2f52514c4a6e3339ad1006b1b6f7 Mon Sep 17 00:00:00 2001
From: "Curtis C. Ober" <ccober@sandia.gov>
Date: Thu, 21 Nov 2019 00:43:46 -0700
Subject: [PATCH 11/21] Tempus: Add Cleanup of Error Tolerances.

---
 .../src/Tempus_SolutionStateMetaData_decl.hpp | 14 ++--
 .../src/Tempus_SolutionStateMetaData_impl.hpp | 14 ++++
 .../tempus/src/Tempus_SolutionState_decl.hpp  | 79 +++++++++++++------
 3 files changed, 75 insertions(+), 32 deletions(-)

diff --git a/packages/tempus/src/Tempus_SolutionStateMetaData_decl.hpp b/packages/tempus/src/Tempus_SolutionStateMetaData_decl.hpp
index ef86418ebcd6..0cf703aad59a 100644
--- a/packages/tempus/src/Tempus_SolutionStateMetaData_decl.hpp
+++ b/packages/tempus/src/Tempus_SolutionStateMetaData_decl.hpp
@@ -41,6 +41,8 @@ class SolutionStateMetaData :
     const int    nFailures,
     const int    nRunningFailures,
     const int    nConsecutiveFailures,
+    const Scalar tolRel,
+    const Scalar tolAbs,
     const Status solutionStatus,
     const bool   output,
     const bool   outputScreen,
@@ -71,14 +73,14 @@ class SolutionStateMetaData :
     int    getNFailures()            const {return nFailures_;}
     int    getNRunningFailures()     const {return nRunningFailures_;}
     int    getNConsecutiveFailures() const {return nConsecutiveFailures_;}
+    Scalar getTolAbs()               const {return tolAbs_;}
+    Scalar getTolRel()               const {return tolRel_;}
     Status getSolutionStatus()       const {return solutionStatus_;}
     bool   getOutput()               const {return output_;}
     bool   getOutputScreen()         const {return outputScreen_;}
     bool   getIsSynced()             const {return isSynced_;}
     bool   getIsInterpolated()       const {return isInterpolated_;}
     Scalar getAccuracy()             const {return accuracy_;}
-    Scalar getTolAbs()               const {return tolAbs_;}
-    Scalar getTolRel()               const {return tolRel_;}
 
     void setTime(Scalar time) {time_ = time;}
     void setIStep(int iStep) {iStep_ = iStep;}
@@ -90,6 +92,8 @@ class SolutionStateMetaData :
     void setNRunningFailures(int nFailures) {nRunningFailures_ = nFailures;}
     void setNConsecutiveFailures(int nConsecutiveFailures)
       {nConsecutiveFailures_ = nConsecutiveFailures;}
+    void setTolRel (Scalar tolRel){tolRel_ = tolRel;}
+    void setTolAbs (Scalar tolAbs){tolAbs_ = tolAbs;}
     void setSolutionStatus(Status solutionStatus)
       {solutionStatus_ = solutionStatus;}
     void setOutput(bool output) {output_ = output;}
@@ -98,9 +102,7 @@ class SolutionStateMetaData :
     void setIsInterpolated(bool isInterpolated)
       {isInterpolated_ = isInterpolated;}
     void setAccuracy(Scalar accuracy) {accuracy_ = accuracy;}
-    void setTolAbs(Scalar tolAbs){tolAbs_ = tolAbs;}
-    void setTolRel(Scalar tolRel){tolRel_ = tolRel;}
-       
+
   //@}
 
   /// \name Overridden from Teuchos::Describable
@@ -120,7 +122,7 @@ class SolutionStateMetaData :
   int nFailures_;            ///< Total number of stepper failures
   int nRunningFailures_;     ///< Total number of running stepper failures
   int nConsecutiveFailures_; ///< Consecutive number of stepper failures
-  Scalar tolRel_;            ///< Absolute tolerance 
+  Scalar tolRel_;            ///< Absolute tolerance
   Scalar tolAbs_;            ///< Relative tolerance
 
   /** \brief The solutionStatus is used to indicate
diff --git a/packages/tempus/src/Tempus_SolutionStateMetaData_impl.hpp b/packages/tempus/src/Tempus_SolutionStateMetaData_impl.hpp
index 4cc517191977..ed966403faa6 100644
--- a/packages/tempus/src/Tempus_SolutionStateMetaData_impl.hpp
+++ b/packages/tempus/src/Tempus_SolutionStateMetaData_impl.hpp
@@ -25,6 +25,8 @@ SolutionStateMetaData<Scalar>::SolutionStateMetaData()
    nFailures_     (0),
    nRunningFailures_(0),
    nConsecutiveFailures_(0),
+   tolRel_        (1.0e-02),
+   tolAbs_        (0.0),
    solutionStatus_(WORKING),
    output_        (false),
    outputScreen_  (false),
@@ -44,6 +46,8 @@ SolutionStateMetaData<Scalar>::SolutionStateMetaData(
   const int    nFailures,
   const int    nRunningFailures,
   const int    nConsecutiveFailures,
+  const Scalar tolRel,
+  const Scalar tolAbs,
   const Status solutionStatus,
   const bool   output,
   const bool   outputScreen,
@@ -59,6 +63,8 @@ SolutionStateMetaData<Scalar>::SolutionStateMetaData(
    nFailures_     (nFailures),
    nRunningFailures_(nRunningFailures),
    nConsecutiveFailures_(nConsecutiveFailures),
+   tolRel_        (tolRel),
+   tolAbs_        (tolAbs),
    solutionStatus_(solutionStatus),
    output_        (output),
    outputScreen_  (outputScreen),
@@ -78,6 +84,8 @@ SolutionStateMetaData<Scalar>::SolutionStateMetaData(const SolutionStateMetaData
    nFailures_     (ssmd.nFailures_),
    nRunningFailures_(ssmd.nRunningFailures_),
    nConsecutiveFailures_(ssmd.nConsecutiveFailures_),
+   tolRel_        (ssmd.tolRel_),
+   tolAbs_        (ssmd.tolAbs_),
    solutionStatus_(ssmd.solutionStatus_),
    output_        (ssmd.output_),
    outputScreen_  (ssmd.outputScreen_),
@@ -101,6 +109,8 @@ Teuchos::RCP<SolutionStateMetaData<Scalar> > SolutionStateMetaData<Scalar>::clon
       nFailures_,
       nRunningFailures_,
       nConsecutiveFailures_,
+      tolRel_,
+      tolAbs_,
       solutionStatus_,
       output_,
       outputScreen_,
@@ -125,6 +135,8 @@ copy(const Teuchos::RCP<const SolutionStateMetaData<Scalar> >& ssmd)
   nFailures_      = ssmd->nFailures_;
   nRunningFailures_= ssmd->nRunningFailures_;
   nConsecutiveFailures_ = ssmd->nConsecutiveFailures_;
+  tolRel_         = ssmd->tolRel_,
+  tolAbs_         = ssmd->tolAbs_,
   solutionStatus_ = ssmd->solutionStatus_;
   output_         = ssmd->output_;
   outputScreen_   = ssmd->outputScreen_;
@@ -158,6 +170,8 @@ void SolutionStateMetaData<Scalar>::describe(
         << "nFailures      = " << nFailures_ << std::endl
         << "nRunningFailures= " << nRunningFailures_<< std::endl
         << "nConsecutiveFailures = " << nConsecutiveFailures_ << std::endl
+        << "tolRel         = " << tolRel_ << std::endl
+        << "tolAbs         = " << tolAbs_ << std::endl
         << "solutionStatus = " << toString(solutionStatus_) << std::endl
         << "output         = " << output_ << std::endl
         << "outputScreen   = " << outputScreen_ << std::endl
diff --git a/packages/tempus/src/Tempus_SolutionState_decl.hpp b/packages/tempus/src/Tempus_SolutionState_decl.hpp
index d64022521f45..84334cbcc901 100644
--- a/packages/tempus/src/Tempus_SolutionState_decl.hpp
+++ b/packages/tempus/src/Tempus_SolutionState_decl.hpp
@@ -125,18 +125,23 @@ class SolutionState :
       { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
         return metaData_nc_; }
 
-    virtual Scalar getTime()     const {return metaData_->getTime();}
-    virtual int getIndex()    const {return metaData_->getIStep();}
-    virtual Scalar getTimeStep() const {return metaData_->getDt();}
-    virtual Scalar getOrder()    const {return metaData_->getOrder();}
-    virtual Scalar getNRunningFailures() const
-      { return metaData_->getNRunningFailures(); }
-    virtual Scalar getNConsecutiveFailures() const
-      { return metaData_->getNConsecutiveFailures(); }
-    virtual Status getSolutionStatus() const
-      { return metaData_->getSolutionStatus(); }
-    virtual bool getOutput()     const {return metaData_->getOutput();}
-    virtual bool getIsSynced()   const {return metaData_->getIsSynced();}
+    virtual Scalar getTime()             const {return metaData_->getTime();}
+    virtual int    getIndex()            const {return metaData_->getIStep();}
+    virtual Scalar getTimeStep()         const {return metaData_->getDt();}
+    virtual Scalar getErrorAbs()         const {return metaData_->getErrorAbs();}
+    virtual Scalar getErrorRel()         const {return metaData_->getErrorRel();}
+    virtual int    getOrder()            const {return metaData_->getOrder();}
+    virtual int    getNFailures()        const {return metaData_->getNFailures();}
+    virtual int    getNRunningFailures() const {return metaData_->getNRunningFailures();}
+    virtual int    getNConsecutiveFailures() const {return metaData_->getNConsecutiveFailures();}
+    virtual Scalar getTolAbs()           const {return metaData_->getTolAbs();}
+    virtual Scalar getTolRel()           const {return metaData_->getTolRel();}
+    virtual Status getSolutionStatus()   const {return metaData_->getSolutionStatus();}
+    virtual bool getOutput()             const {return metaData_->getOutput();}
+    virtual bool getOutputScreen()       const {return metaData_->getOutputScreen();}
+    virtual bool getIsSynced()           const {return metaData_->getIsSynced();}
+    virtual bool getIsInterpolated()     const {return metaData_->getIsInterpolated();}
+    virtual bool getAccuracy()           const {return metaData_->getAccuracy();}
   //@}
 
   /// \name Set MetaData values
@@ -147,15 +152,33 @@ class SolutionState :
     virtual void setMetaData(Teuchos::RCP<SolutionStateMetaData<Scalar> > md)
       { metaData_nc_ = md; metaData_ = metaData_nc_; }
 
-    virtual void setTime(Scalar time)   {metaData_nc_->setTime(time);}
-    virtual void setIndex(Scalar index) {metaData_nc_->setIStep(index);}
-    virtual void setTimeStep(Scalar dt) {metaData_nc_->setDt(dt);}
-    virtual void setOrder(Scalar order)
+    virtual void setTime(Scalar time)   { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setTime(time);}
+    virtual void setIndex(Scalar index) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setIStep(index);}
+    virtual void setTimeStep(Scalar dt) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setDt(dt);}
+    virtual void setErrorAbs(Scalar errorAbs){ TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                               metaData_nc_->setErrorAbs(errorAbs);}
+    virtual void setErrorRel(Scalar errorRel){ TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                               metaData_nc_->setErrorRel(errorRel);}
+    virtual void setOrder(int order) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setOrder(order); }
+
+    virtual void setNFailures(int nFailures) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                               metaData_nc_->setNFailures(nFailures); }
+    virtual void setNRunningFailures(int nFailures) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setNRunningFailures(nFailures); }
+    virtual void setNConsecutiveFailures(int nConsecutiveFailures)
       { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
-        metaData_nc_->setOrder(order); }
-    virtual void setSolutionStatus(Status s)
-      { metaData_nc_->setSolutionStatus(s); }
-
+                                          metaData_nc_->setNConsecutiveFailures(nConsecutiveFailures); }
+    virtual void setTolRel (Scalar tolRel){ TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setTolRel(tolRel); }
+    virtual void setTolAbs (Scalar tolAbs){ TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setTolAbs(tolAbs); }
+
+    virtual void setSolutionStatus(Status s) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                               metaData_nc_->setSolutionStatus(s); }
     virtual void setSolutionStatus(const Thyra::SolveStatus<Scalar> sStatus)
       {
         if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED )
@@ -164,12 +187,16 @@ class SolutionState :
           metaData_nc_->setSolutionStatus(Status::FAILED);
       }
 
-    virtual void setOutput(bool output)
-      { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
-        metaData_nc_->setOutput(output); }
-    virtual void setIsSynced(bool isSynced)
-      {  TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
-         metaData_nc_->setIsSynced(isSynced); }
+    virtual void setOutput(bool output) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                          metaData_nc_->setOutput(output); }
+    virtual void setOutputScreen(bool output) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                                metaData_nc_->setOutputScreen(output); }
+    virtual void setIsSynced(bool isSynced) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                              metaData_nc_->setIsSynced(isSynced); }
+    virtual void setIsInterpolated(bool isInterpolated) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                              metaData_nc_->setIsInterpolated(isInterpolated); }
+    virtual void setAccuracy(bool accuracy) { TEUCHOS_ASSERT(metaData_nc_ != Teuchos::null);
+                                              metaData_nc_->setAccuracy(accuracy); }
   //@}
 
   /// \name Get State Data

From 9adcdad2bcd80bd77e05ab3d3cee059772631295 Mon Sep 17 00:00:00 2001
From: "Nathan V. Roberts" <nvrober@sandia.gov>
Date: Thu, 21 Nov 2019 10:22:54 -0700
Subject: [PATCH 12/21] Intrepid2: tweaks to
 OrientationTools::modifyBasisByOrientation() to allow reference-space inputs.

Modified tests for hexahedron, quadrilateral, tetrahedron, and triangle so that these now exercise the new code path as well as the old.  Also tweaked those tests slightly to fix an issue where some code that was in a cell loop should not have been in a cell loop (the code was not wrong, but slightly less precise than it might have been).
---
 ...trepid2_OrientationToolsDefModifyBasis.hpp | 28 ++++++++++----
 .../Orientation/test_orientation_HEX.hpp      | 37 +++++++++----------
 .../Orientation/test_orientation_QUAD.hpp     | 34 ++++++++---------
 .../Orientation/test_orientation_TET.hpp      | 34 ++++++++---------
 .../Orientation/test_orientation_TRI.hpp      | 36 +++++++++---------
 5 files changed, 91 insertions(+), 78 deletions(-)

diff --git a/packages/intrepid2/src/Orientation/Intrepid2_OrientationToolsDefModifyBasis.hpp b/packages/intrepid2/src/Orientation/Intrepid2_OrientationToolsDefModifyBasis.hpp
index d9a1e79347ca..11c37e68dfde 100644
--- a/packages/intrepid2/src/Orientation/Intrepid2_OrientationToolsDefModifyBasis.hpp
+++ b/packages/intrepid2/src/Orientation/Intrepid2_OrientationToolsDefModifyBasis.hpp
@@ -170,7 +170,9 @@ namespace Intrepid2 {
       typedef typename inputViewType::non_const_value_type input_value_type;
 
       auto out = Kokkos::subview(output, cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto in  = Kokkos::subview(input,  cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+      auto in  = (input.rank() == output.rank()) ?
+                 Kokkos::subview(input,  cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL())
+               : Kokkos::subview(input,        Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
 
       // vertex copy (no orientation)
       for (ordinal_type vertId=0;vertId<numVerts;++vertId) {
@@ -276,13 +278,25 @@ namespace Intrepid2 {
                            const BasisPtrType basis ) {
 #ifdef HAVE_INTREPID2_DEBUG
     {
-      INTREPID2_TEST_FOR_EXCEPTION( input.rank() != output.rank(), std::invalid_argument,
-                                    ">>> ERROR (OrientationTools::modifyBasisByOrientation): Input and output rank are not 3.");
-      for (size_type i=0;i<input.rank();++i)
-        INTREPID2_TEST_FOR_EXCEPTION( input.extent(i) != output.extent(i), std::invalid_argument,
-                                      ">>> ERROR (OrientationTools::modifyBasisByOrientation): Input and output dimension does not match.");
+      if (input.rank() == output.rank())
+      {
+        for (size_type i=0;i<input.rank();++i)
+          INTREPID2_TEST_FOR_EXCEPTION( input.extent(i) != output.extent(i), std::invalid_argument,
+                                        ">>> ERROR (OrientationTools::modifyBasisByOrientation): Input and output dimension does not match.");
+      }
+      else if (input.rank() == output.rank() - 1)
+      {
+        for (size_type i=0;i<input.rank();++i)
+          INTREPID2_TEST_FOR_EXCEPTION( input.extent(i) != output.extent(i+1), std::invalid_argument,
+                                       ">>> ERROR (OrientationTools::modifyBasisByOrientation): Input dimensions must match output dimensions exactly, or else match all but the first dimension (in the case that input does not have a 'cell' dimension).");
+      }
+      else
+      {
+        INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument,
+                                     ">>> ERROR (OrientationTools::modifyBasisByOrientation): input and output ranks must either match, or input rank must be one less than that of output.")
+      }
 
-      INTREPID2_TEST_FOR_EXCEPTION( static_cast<ordinal_type>(input.extent(1)) != basis->getCardinality(), std::invalid_argument,
+      INTREPID2_TEST_FOR_EXCEPTION( static_cast<ordinal_type>(output.extent(1)) != basis->getCardinality(), std::invalid_argument,
                                     ">>> ERROR (OrientationTools::modifyBasisByOrientation): Field dimension of input/output does not match to basis cardinality.");
     }
 #endif
diff --git a/packages/intrepid2/unit-test/Orientation/test_orientation_HEX.hpp b/packages/intrepid2/unit-test/Orientation/test_orientation_HEX.hpp
index 8fff1b432c84..9cb30be616ae 100644
--- a/packages/intrepid2/unit-test/Orientation/test_orientation_HEX.hpp
+++ b/packages/intrepid2/unit-test/Orientation/test_orientation_HEX.hpp
@@ -42,7 +42,7 @@
 
 
 /** \file
-    \brief  Test for checking orientation tools for Hexaedral elements
+    \brief  Test for checking orientation tools for Hexahedral elements
  
     The test considers two hexahedra in the physical space sharing a common face. 
     In order to test significant configurations, we consider 6 mappings of the reference hexahedron
@@ -456,25 +456,26 @@ int OrientationHex(const bool verbose) {
 
        //Testing Kronecker property of basis functions
        {
+         DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
          for(ordinal_type i=0; i<numCells; ++i) {
-           DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
            auto inView = Kokkos::subview( dofCoordsOriented,i,Kokkos::ALL(),Kokkos::ALL());
            auto outView =Kokkos::subview( basisValuesAtDofCoords,i,Kokkos::ALL(),Kokkos::ALL());
            basis.getValues(outView, inView);
+         }
 
-           // modify basis values to account for orientations
-           ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoords,
-               elemOrts,
-               &basis);
-
-           // transform basis values
-           deep_copy(transformedBasisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoordsOriented);
+         // modify basis values to account for orientations
+         ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
+                                       basisValuesAtDofCoords,
+                                       elemOrts,
+                                       &basis);
 
+         // transform basis values
+         deep_copy(transformedBasisValuesAtDofCoordsOriented,
+                   basisValuesAtDofCoordsOriented);
 
+         for(ordinal_type i=0; i<numCells; ++i) {
            for(ordinal_type k=0; k<basisCardinality; ++k) {
              for(ordinal_type j=0; j<basisCardinality; ++j){
                ValueType dofValue = transformedBasisValuesAtDofCoordsOriented(i,k,j) * dofCoeffsPhys(i,j);
@@ -493,7 +494,7 @@ int OrientationHex(const bool verbose) {
          }
        }
 
-       //check function reproducbility
+       //check function reproducibility
        Fun fun;
        DynRankView ConstructWithLabel(funDofs, numCells, basisCardinality);
        DynRankView ConstructWithLabel(funAtPhysRefCoords, numCells, numRefCoords);
@@ -555,17 +556,15 @@ int OrientationHex(const bool verbose) {
        //check that fun values at reference points coincide with those computed using basis functions
        DynRankView ConstructWithLabel(basisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
        DynRankView ConstructWithLabel(transformedBasisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
-       DynRankView basisValuesAtRefCoordsCells("inValues", numCells, basisCardinality, numRefCoords);
 
        DynRankView ConstructWithLabel(basisValuesAtRefCoords, basisCardinality, numRefCoords);
        basis.getValues(basisValuesAtRefCoords, refPoints);
-       rst::clone(basisValuesAtRefCoordsCells,basisValuesAtRefCoords);
 
        // modify basis values to account for orientations
        ots::modifyBasisByOrientation(basisValuesAtRefCoordsOriented,
-           basisValuesAtRefCoordsCells,
-           elemOrts,
-           &basis);
+                                     basisValuesAtRefCoords,
+                                     elemOrts,
+                                     &basis);
 
        // transform basis values
        deep_copy(transformedBasisValuesAtRefCoordsOriented,
diff --git a/packages/intrepid2/unit-test/Orientation/test_orientation_QUAD.hpp b/packages/intrepid2/unit-test/Orientation/test_orientation_QUAD.hpp
index 7abc40c5ef3f..7fe6f1352767 100644
--- a/packages/intrepid2/unit-test/Orientation/test_orientation_QUAD.hpp
+++ b/packages/intrepid2/unit-test/Orientation/test_orientation_QUAD.hpp
@@ -362,25 +362,27 @@ int OrientationQuad(const bool verbose) {
 
        //Testing Kronecker property of basis functions
        {
+         DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         
          for(ordinal_type i=0; i<numCells; ++i) {
-           DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
            auto inView = Kokkos::subview( dofCoordsOriented,i,Kokkos::ALL(),Kokkos::ALL());
            auto outView =Kokkos::subview( basisValuesAtDofCoords,i,Kokkos::ALL(),Kokkos::ALL());
            basis.getValues(outView, inView);
+         }
 
-           // modify basis values to account for orientations
-           ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoords,
-               elemOrts,
-               &basis);
-
-           // transform basis values
-           deep_copy(transformedBasisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoordsOriented);
+         // modify basis values to account for orientations
+         ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
+                                       basisValuesAtDofCoords,
+                                       elemOrts,
+                                       &basis);
 
+         // transform basis values
+         deep_copy(transformedBasisValuesAtDofCoordsOriented,
+                   basisValuesAtDofCoordsOriented);
 
+         for(ordinal_type i=0; i<numCells; ++i) {
            for(ordinal_type k=0; k<basisCardinality; ++k) {
              for(ordinal_type j=0; j<basisCardinality; ++j){
                ValueType dofValue = transformedBasisValuesAtDofCoordsOriented(i,k,j) * dofCoeffsPhys(i,j);
@@ -437,17 +439,15 @@ int OrientationQuad(const bool verbose) {
        //check that fun values at reference points coincide with those computed using basis functions
        DynRankView ConstructWithLabel(basisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
        DynRankView ConstructWithLabel(transformedBasisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
-       DynRankView basisValuesAtRefCoordsCells("inValues", numCells, basisCardinality, numRefCoords);
 
        DynRankView ConstructWithLabel(basisValuesAtRefCoords, basisCardinality, numRefCoords);
        basis.getValues(basisValuesAtRefCoords, refPoints);
-       rst::clone(basisValuesAtRefCoordsCells,basisValuesAtRefCoords);
 
        // modify basis values to account for orientations
        ots::modifyBasisByOrientation(basisValuesAtRefCoordsOriented,
-           basisValuesAtRefCoordsCells,
-           elemOrts,
-           &basis);
+                                     basisValuesAtRefCoords,
+                                     elemOrts,
+                                     &basis);
 
        // transform basis values
        deep_copy(transformedBasisValuesAtRefCoordsOriented,
diff --git a/packages/intrepid2/unit-test/Orientation/test_orientation_TET.hpp b/packages/intrepid2/unit-test/Orientation/test_orientation_TET.hpp
index 2eb852b39f42..62ad3df67985 100644
--- a/packages/intrepid2/unit-test/Orientation/test_orientation_TET.hpp
+++ b/packages/intrepid2/unit-test/Orientation/test_orientation_TET.hpp
@@ -423,25 +423,27 @@ int OrientationTet(const bool verbose) {
 
        //Testing Kronecker property of basis functions
        {
+         DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         
          for(ordinal_type i=0; i<numCells; ++i) {
-           DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
            auto inView = Kokkos::subview( dofCoordsOriented,i,Kokkos::ALL(),Kokkos::ALL());
            auto outView =Kokkos::subview( basisValuesAtDofCoords,i,Kokkos::ALL(),Kokkos::ALL());
            basis.getValues(outView, inView);
+         }
 
-           // modify basis values to account for orientations
-           ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoords,
-               elemOrts,
-               &basis);
-
-           // transform basis values
-           deep_copy(transformedBasisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoordsOriented);
+         // modify basis values to account for orientations
+         ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
+                                       basisValuesAtDofCoords,
+                                       elemOrts,
+                                       &basis);
 
+         // transform basis values
+         deep_copy(transformedBasisValuesAtDofCoordsOriented,
+                   basisValuesAtDofCoordsOriented);
 
+         for(ordinal_type i=0; i<numCells; ++i) {
            for(ordinal_type k=0; k<basisCardinality; ++k) {
              for(ordinal_type j=0; j<basisCardinality; ++j){
                ValueType dofValue = transformedBasisValuesAtDofCoordsOriented(i,k,j) * dofCoeffsPhys(i,j);
@@ -522,17 +524,15 @@ int OrientationTet(const bool verbose) {
        //check that fun values at reference points coincide with those computed using basis functions
        DynRankView ConstructWithLabel(basisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
        DynRankView ConstructWithLabel(transformedBasisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
-       DynRankView basisValuesAtRefCoordsCells("inValues", numCells, basisCardinality, numRefCoords);
 
        DynRankView ConstructWithLabel(basisValuesAtRefCoords, basisCardinality, numRefCoords);
        basis.getValues(basisValuesAtRefCoords, refPoints);
-       rst::clone(basisValuesAtRefCoordsCells,basisValuesAtRefCoords);
 
        // modify basis values to account for orientations
        ots::modifyBasisByOrientation(basisValuesAtRefCoordsOriented,
-           basisValuesAtRefCoordsCells,
-           elemOrts,
-           &basis);
+                                     basisValuesAtRefCoords,
+                                     elemOrts,
+                                     &basis);
 
        // transform basis values
        deep_copy(transformedBasisValuesAtRefCoordsOriented,
diff --git a/packages/intrepid2/unit-test/Orientation/test_orientation_TRI.hpp b/packages/intrepid2/unit-test/Orientation/test_orientation_TRI.hpp
index 6c7e659b83d5..89ba09a32548 100644
--- a/packages/intrepid2/unit-test/Orientation/test_orientation_TRI.hpp
+++ b/packages/intrepid2/unit-test/Orientation/test_orientation_TRI.hpp
@@ -362,25 +362,27 @@ int OrientationTri(const bool verbose) {
 
        //Testing Kronecker property of basis functions
        {
+         DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
+         
          for(ordinal_type i=0; i<numCells; ++i) {
-           DynRankView ConstructWithLabel(basisValuesAtDofCoords, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(basisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
-           DynRankView ConstructWithLabel(transformedBasisValuesAtDofCoordsOriented, numCells, basisCardinality, basisCardinality);
            auto inView = Kokkos::subview( dofCoordsOriented,i,Kokkos::ALL(),Kokkos::ALL());
            auto outView =Kokkos::subview( basisValuesAtDofCoords,i,Kokkos::ALL(),Kokkos::ALL());
            basis.getValues(outView, inView);
+         }
 
-           // modify basis values to account for orientations
-           ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoords,
-               elemOrts,
-               &basis);
-
-           // transform basis values
-           deep_copy(transformedBasisValuesAtDofCoordsOriented,
-               basisValuesAtDofCoordsOriented);
+         // modify basis values to account for orientations
+         ots::modifyBasisByOrientation(basisValuesAtDofCoordsOriented,
+                                       basisValuesAtDofCoords,
+                                       elemOrts,
+                                       &basis);
 
+         // transform basis values
+         deep_copy(transformedBasisValuesAtDofCoordsOriented,
+                   basisValuesAtDofCoordsOriented);
 
+         for(ordinal_type i=0; i<numCells; ++i) {
            for(ordinal_type k=0; k<basisCardinality; ++k) {
              for(ordinal_type j=0; j<basisCardinality; ++j){
                ValueType dofValue = transformedBasisValuesAtDofCoordsOriented(i,k,j) * dofCoeffsPhys(i,j);
@@ -437,21 +439,19 @@ int OrientationTri(const bool verbose) {
        //check that fun values at reference points coincide with those computed using basis functions
        DynRankView ConstructWithLabel(basisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
        DynRankView ConstructWithLabel(transformedBasisValuesAtRefCoordsOriented, numCells, basisCardinality, numRefCoords);
-       DynRankView basisValuesAtRefCoordsCells("inValues", numCells, basisCardinality, numRefCoords);
 
        DynRankView ConstructWithLabel(basisValuesAtRefCoords, basisCardinality, numRefCoords);
        basis.getValues(basisValuesAtRefCoords, refPoints);
-       rst::clone(basisValuesAtRefCoordsCells,basisValuesAtRefCoords);
 
        // modify basis values to account for orientations
        ots::modifyBasisByOrientation(basisValuesAtRefCoordsOriented,
-           basisValuesAtRefCoordsCells,
-           elemOrts,
-           &basis);
+                                     basisValuesAtRefCoords,
+                                     elemOrts,
+                                     &basis);
 
        // transform basis values
        deep_copy(transformedBasisValuesAtRefCoordsOriented,
-           basisValuesAtRefCoordsOriented);
+                 basisValuesAtRefCoordsOriented);
 
        DynRankView ConstructWithLabel(funAtRefCoordsOriented, numCells, numRefCoords);
        for(ordinal_type i=0; i<numCells; ++i) {

From ba3496381eb71213ba41ca5481a6e088f13c7cc5 Mon Sep 17 00:00:00 2001
From: Luc Berger-Vergiat <lberge@sandia.gov>
Date: Wed, 20 Nov 2019 14:22:27 -0700
Subject: [PATCH 13/21] MueLu: refactor of Dirichlet conditions handling and
 changes in UncoupledAggregation see issue #6269

Three main changes are made in this commit:
    1. the Dirichlet phase of aggregation is refactored and associted
    utilities in UncoupledAggregation are refactored using Kokkos.
    A related bug in AggregationPhase1_kokkos is fixed.

    2. the default behavior of UncoupledAggregation is changed.
    The BuildSerialAggregates method is removed from Phase 1
    which means that now aggregation will always be performed in
    parallel and on device if possible. It simplifies slightly the
    input parameters for aggregation.

    3. some preparations are made to change the coloring
    algorithm selection for UncoupledAggregation, ultiately it
    is desireable to run with something else than the host serial
    implementation of distance 2 coloring but more tests with the
    different coloring algorithms will be needed first.
---
 packages/muelu/doc/UsersGuide/masterList.xml  |   6 +-
 .../doc/UsersGuide/options_aggregation.tex    |   2 +-
 packages/muelu/doc/UsersGuide/paramlist.tex   |   2 +-
 .../muelu/doc/UsersGuide/paramlist_hidden.tex |   2 +-
 ...AggregationPhase1Algorithm_kokkos_decl.hpp |  39 +-
 ..._AggregationPhase1Algorithm_kokkos_def.hpp | 294 +++----------
 ...richletAggregationAlgorithm_kokkos_def.hpp |  83 ++--
 ...UncoupledAggregationFactory_kokkos_def.hpp |  44 +-
 .../muelu/src/MueCentral/MueLu_MasterList.cpp |   4 +-
 .../muelu/test/unit_tests/RegionMatrix.cpp    |  52 ++-
 .../unit_tests_kokkos/Aggregates_kokkos.cpp   | 388 ++++++++++++------
 11 files changed, 432 insertions(+), 484 deletions(-)

diff --git a/packages/muelu/doc/UsersGuide/masterList.xml b/packages/muelu/doc/UsersGuide/masterList.xml
index 17a4186341a5..0e6724af0c61 100644
--- a/packages/muelu/doc/UsersGuide/masterList.xml
+++ b/packages/muelu/doc/UsersGuide/masterList.xml
@@ -462,10 +462,10 @@
     </parameter>
 
     <parameter>
-      <name>aggregation: phase 1 algorithm</name>
+      <name>aggregation: coloring algorithm</name>
       <type>string</type>
-      <default>Serial</default>
-      <description>Choice of algorithm for aggregation phase 1.</description>
+      <default>default</default>
+      <description>Choice of distance 2 coloring algorithm used by Uncoupled Aggregation. Currently always set to COLORING_D2_SERIAL.</description>
       <comment-ML>parameter not existing in ML</comment-ML>
     </parameter>
 
diff --git a/packages/muelu/doc/UsersGuide/options_aggregation.tex b/packages/muelu/doc/UsersGuide/options_aggregation.tex
index 8b4ba886e07f..4c0f5c917a6d 100644
--- a/packages/muelu/doc/UsersGuide/options_aggregation.tex
+++ b/packages/muelu/doc/UsersGuide/options_aggregation.tex
@@ -23,7 +23,7 @@
           
 \cbb{aggregation: deterministic}{bool}{false}{Boolean indicating whether or not aggregation will be run deterministically in the kokkos refactored path (only used in uncoupled aggregation).}
           
-\cbb{aggregation: phase 1 algorithm}{string}{Serial}{Choice of algorithm for aggregation phase 1.}
+\cbb{aggregation: coloring algorithm}{string}{default}{Choice of distance 2 coloring algorithm used by Uncoupled Aggregation. Currently always set to COLORING_D2_SERIAL.}
           
 \cbb{aggregation: export visualization data}{bool}{false}{Export data for visualization post-processing.}
           
diff --git a/packages/muelu/doc/UsersGuide/paramlist.tex b/packages/muelu/doc/UsersGuide/paramlist.tex
index 84b12b700112..339203a6e3e2 100644
--- a/packages/muelu/doc/UsersGuide/paramlist.tex
+++ b/packages/muelu/doc/UsersGuide/paramlist.tex
@@ -70,7 +70,7 @@
           
 \cbb{aggregation: deterministic}{bool}{false}{Boolean indicating whether or not aggregation will be run deterministically in the kokkos refactored path (only used in uncoupled aggregation).}
           
-\cbb{aggregation: phase 1 algorithm}{string}{Serial}{Choice of algorithm for aggregation phase 1.}
+\cbb{aggregation: coloring algorithm}{string}{default}{Choice of distance 2 coloring algorithm used by Uncoupled Aggregation. Currently always set to COLORING_D2_SERIAL.}
           
 \cbb{aggregation: export visualization data}{bool}{false}{Export data for visualization post-processing.}
           
diff --git a/packages/muelu/doc/UsersGuide/paramlist_hidden.tex b/packages/muelu/doc/UsersGuide/paramlist_hidden.tex
index a27402181790..42941d5428a3 100644
--- a/packages/muelu/doc/UsersGuide/paramlist_hidden.tex
+++ b/packages/muelu/doc/UsersGuide/paramlist_hidden.tex
@@ -80,7 +80,7 @@
         
 \cbb{aggregation: deterministic}{bool}{false}{Boolean indicating whether or not aggregation will be run deterministically in the kokkos refactored path (only used in uncoupled aggregation).}
         
-\cbb{aggregation: phase 1 algorithm}{string}{Serial}{Choice of algorithm for aggregation phase 1.}
+\cbb{aggregation: coloring algorithm}{string}{default}{Choice of distance 2 coloring algorithm used by Uncoupled Aggregation. Currently always set to COLORING_D2_SERIAL.}
         
 \cbb{aggregation: enable phase 1}{bool}{true}{Turn on/off phase 1 of aggregation}
         
diff --git a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_decl.hpp b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_decl.hpp
index ba7c0417daa1..a57b1f0564d2 100644
--- a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_decl.hpp
+++ b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_decl.hpp
@@ -117,16 +117,11 @@ namespace MueLu {
                          Kokkos::View<unsigned*, memory_space>& aggStat,
                          LO& numNonAggregatedNodes) const;
 
-    void BuildAggregatesSerial(const LWGraph_kokkos& graph, Aggregates_kokkos& aggregates,
-                               std::vector<unsigned>& aggStat, LO& numNonAggregatedNodes,
-                               LO minNodesPerAggregate, LO maxNodesPerAggregate,
-                               LO maxNeighAlreadySelected, std::string& orderingStr) const;
-
-    void BuildAggregatesDistance2(const LO maxAggSize,
-                                  const LWGraph_kokkos& graph,
-                                  Aggregates_kokkos& aggregates,
-                                  Kokkos::View<unsigned*, memory_space>& aggStat,
-                                  LO& numNonAggregatedNodes) const;
+    void BuildAggregatesRandom(const LO maxAggSize,
+                               const LWGraph_kokkos& graph,
+                               Aggregates_kokkos& aggregates,
+                               Kokkos::View<unsigned*, memory_space>& aggStat,
+                               LO& numNonAggregatedNodes) const;
 
     void BuildAggregatesDeterministic(const LO maxAggSize,
                                       const LWGraph_kokkos& graph,
@@ -137,30 +132,6 @@ namespace MueLu {
 
     std::string description() const { return "Phase 1 (main)"; }
 
-    enum struct Algorithm
-    {
-      Serial,
-      Distance2
-    };
-
-    static Algorithm algorithmFromName(const std::string& name)
-    {
-      if(name == "Distance2")
-        return Algorithm::Distance2;
-      return Algorithm::Serial;
-    }
-
-  private:
-
-    /*! @brief Utility to take a list of integers and reorder them randomly (by using a local permutation).
-      @param list On input, a bunch of integers. On output, the same integers in a different order
-      that is determined randomly.
-    */
-    void RandomReorder(ArrayRCP<LO> list) const;
-
-    /*! @brief Generate a random number in the range [min, max] */
-    int RandomOrdinal(int min, int max) const;
-
   };
 
 } //namespace MueLu
diff --git a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_def.hpp b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_def.hpp
index a5fe99d80eda..66843df95a86 100644
--- a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_def.hpp
+++ b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase1Algorithm_kokkos_def.hpp
@@ -78,26 +78,17 @@ namespace MueLu {
 
     using memory_space = typename LWGraph_kokkos::memory_space;
 
-    std::string orderingStr     = params.get<std::string>("aggregation: ordering");
-    int maxNeighAlreadySelected = params.get<int>        ("aggregation: max selected neighbors");
     int minNodesPerAggregate    = params.get<int>        ("aggregation: min agg size");
     int maxNodesPerAggregate    = params.get<int>        ("aggregation: max agg size");
 
-    Algorithm algorithm         = Algorithm::Serial;
-    std::string algoParamName = "aggregation: phase 1 algorithm";
-    if(params.isParameter(algoParamName))
-    {
-      algorithm = algorithmFromName(params.get<std::string>(algoParamName));
-    }
-
     TEUCHOS_TEST_FOR_EXCEPTION(maxNodesPerAggregate < minNodesPerAggregate,
                                Exceptions::RuntimeError,
                                "MueLu::UncoupledAggregationAlgorithm::BuildAggregates: minNodesPerAggregate must be smaller or equal to MaxNodePerAggregate!");
 
-    //Distance-2 gives less control than serial uncoupled phase 1
-    //no custom row reordering because would require making deep copy of local matrix entries and permuting it
-    //can only enforce max aggregate size
-    if(algorithm == Algorithm::Distance2)
+    // Distance-2 gives less control than serial uncoupled phase 1
+    // no custom row reordering because would require making deep copy
+    // of local matrix entries and permuting it can only enforce
+    // max aggregate size
     {
       if(params.get<bool>("aggregation: deterministic"))
       {
@@ -106,200 +97,19 @@ namespace MueLu {
                                      aggregates, aggStat, numNonAggregatedNodes);
       } else {
         Monitor m(*this, "BuildAggregatesRandom");
-        BuildAggregatesDistance2(maxNodesPerAggregate, graph,
-                                 aggregates, aggStat, numNonAggregatedNodes);
-      }
-    }
-    else
-    {
-      Monitor m(*this, "BuildAggregatesSerial");
-      typename Kokkos::View<unsigned*, memory_space>::HostMirror aggStatHost
-        = Kokkos::create_mirror(aggStat);
-      Kokkos::deep_copy(aggStatHost, aggStat);
-      std::vector<unsigned> aggstat;
-      aggstat.resize(aggStatHost.extent(0));
-      for(size_t idx = 0; idx < aggStatHost.extent(0); ++idx) {
-        aggstat[idx] = aggStatHost(idx);
-      }
-
-      BuildAggregatesSerial(graph, aggregates, aggstat, numNonAggregatedNodes, minNodesPerAggregate,
-                            maxNodesPerAggregate, maxNeighAlreadySelected, orderingStr);
-
-      for(size_t idx = 0; idx < aggStatHost.extent(0); ++idx) {
-        aggStatHost(idx) = aggstat[idx];
+        BuildAggregatesRandom(maxNodesPerAggregate, graph,
+                              aggregates, aggStat, numNonAggregatedNodes);
       }
-      Kokkos::deep_copy(aggStat, aggStatHost);
     }
   }
 
-
   template <class LocalOrdinal, class GlobalOrdinal, class Node>
   void AggregationPhase1Algorithm_kokkos<LocalOrdinal, GlobalOrdinal, Node>::
-  BuildAggregatesSerial(const LWGraph_kokkos& graph, Aggregates_kokkos& aggregates,
-                        std::vector<unsigned>& aggStat, LO& numNonAggregatedNodes,
-                        LO minNodesPerAggregate, LO maxNodesPerAggregate,
-                        LO maxNeighAlreadySelected, std::string& orderingStr) const
-  {
-    enum {
-      O_NATURAL,
-      O_RANDOM,
-      O_GRAPH
-    } ordering;
-
-    ordering = O_NATURAL; // initialize variable (fix CID 143665)
-    if (orderingStr == "natural") ordering = O_NATURAL;
-    if (orderingStr == "random" ) ordering = O_RANDOM;
-    if (orderingStr == "graph"  ) ordering = O_GRAPH;
-
-    const LO  numRows = graph.GetNodeNumVertices();
-    const int myRank  = graph.GetComm()->getRank();
-
-    ArrayRCP<LO> vertex2AggId = aggregates.GetVertex2AggId()->getDataNonConst(0);
-    ArrayRCP<LO> procWinner   = aggregates.GetProcWinner()  ->getDataNonConst(0);
-
-    LO numLocalAggregates = aggregates.GetNumAggregates();
-
-    ArrayRCP<LO> randomVector;
-    if (ordering == O_RANDOM) {
-      randomVector = arcp<LO>(numRows);
-      for (LO i = 0; i < numRows; i++)
-        randomVector[i] = i;
-      RandomReorder(randomVector);
-    }
-
-    int              aggIndex = -1;
-    size_t           aggSize  =  0;
-    std::vector<int> aggList(graph.getNodeMaxNumRowEntries());
-
-    std::queue<LO>   graphOrderQueue;
-
-    // Main loop over all local rows of graph(A)
-    for (LO i = 0; i < numRows; i++) {
-      // Step 1: pick the next node to aggregate
-      LO rootCandidate = 0;
-      if      (ordering == O_NATURAL) rootCandidate = i;
-      else if (ordering == O_RANDOM)  rootCandidate = randomVector[i];
-      else if (ordering == O_GRAPH) {
-
-        if (graphOrderQueue.size() == 0) {
-          // Current queue is empty for "graph" ordering, populate with one READY node
-          for (LO jnode = 0; jnode < numRows; jnode++)
-            if (aggStat[jnode] == READY) {
-              graphOrderQueue.push(jnode);
-              break;
-            }
-        }
-        if (graphOrderQueue.size() == 0) {
-          // There are no more ready nodes, end the phase
-          break;
-        }
-        rootCandidate = graphOrderQueue.front();   // take next node from graph ordering queue
-        graphOrderQueue.pop();                     // delete this node in list
-      }
-
-      if (aggStat[rootCandidate] != READY)
-        continue;
-
-      // Step 2: build tentative aggregate
-      aggSize = 0;
-      aggList[aggSize++] = rootCandidate;
-
-      auto neighOfINode = graph.getNeighborVertices(rootCandidate);
-
-      // If the number of neighbors is less than the minimum number of nodes
-      // per aggregate, we know this is not going to be a valid root, and we
-      // may skip it, but only for "natural" and "random" (for "graph" we still
-      // need to fetch the list of local neighbors to continue)
-      if ((ordering == O_NATURAL || ordering == O_RANDOM) &&
-          as<int>(neighOfINode.length) < minNodesPerAggregate) {
-        continue;
-      }
-
-      LO numAggregatedNeighbours = 0;
-
-      for (int j = 0; j < as<int>(neighOfINode.length); j++) {
-        LO neigh = neighOfINode(j);
-
-        if (neigh != rootCandidate && graph.isLocalNeighborVertex(neigh)) {
-
-          if (aggStat[neigh] == READY || aggStat[neigh] == NOTSEL) {
-            // If aggregate size does not exceed max size, add node to the
-            // tentative aggregate
-            // NOTE: We do not exit the loop over all neighbours since we have
-            // still to count all aggregated neighbour nodes for the
-            // aggregation criteria
-            // NOTE: We check here for the maximum aggregation size. If we
-            // would do it below with all the other check too big aggregates
-            // would not be accepted at all.
-            if (aggSize < as<size_t>(maxNodesPerAggregate))
-              aggList[aggSize++] = neigh;
-
-          } else {
-            numAggregatedNeighbours++;
-          }
-        }
-      }
-
-      // Step 3: check if tentative aggregate is acceptable
-      if ((numAggregatedNeighbours <= maxNeighAlreadySelected) &&           // too many connections to other aggregates
-          (aggSize                 >= as<size_t>(minNodesPerAggregate))) {  // too few nodes in the tentative aggregate
-        // Accept new aggregate
-        // rootCandidate becomes the root of the newly formed aggregate
-        aggregates.SetIsRoot(rootCandidate);
-        aggIndex = numLocalAggregates++;
-
-        for (size_t k = 0; k < aggSize; k++) {
-          aggStat     [aggList[k]] = AGGREGATED;
-          vertex2AggId[aggList[k]] = aggIndex;
-          procWinner  [aggList[k]] = myRank;
-        }
-
-        numNonAggregatedNodes -= aggSize;
-
-      } else {
-        // Aggregate is not accepted
-        aggStat[rootCandidate] = NOTSEL;
-
-        // Need this for the "graph" ordering below
-        // The original candidate is always aggList[0]
-        aggSize = 1;
-      }
-
-      if (ordering == O_GRAPH) {
-        // Add candidates to the list of nodes
-        // NOTE: the code have slightly different meanings depending on context:
-        //  - if aggregate was accepted, we add neighbors of neighbors of the original candidate
-        //  - if aggregate was not accepted, we add neighbors of the original candidate
-        for (size_t k = 0; k < aggSize; k++) {
-          auto neighOfJNode = graph.getNeighborVertices(aggList[k]);
-
-          for (int j = 0; j < as<int>(neighOfJNode.length); j++) {
-            LO neigh = neighOfJNode(j);
-
-            if (graph.isLocalNeighborVertex(neigh) && aggStat[neigh] == READY)
-              graphOrderQueue.push(neigh);
-          }
-        }
-      }
-    }
-
-    // Reset all NOTSEL vertices to READY
-    // This simplifies other algorithms
-    for (LO i = 0; i < numRows; i++)
-      if (aggStat[i] == NOTSEL)
-        aggStat[i] = READY;
-
-    // update aggregate object
-    aggregates.SetNumAggregates(numLocalAggregates);
-  }
-
-  template <class LocalOrdinal, class GlobalOrdinal, class Node>
-  void AggregationPhase1Algorithm_kokkos<LocalOrdinal, GlobalOrdinal, Node>::
-  BuildAggregatesDistance2(const LO maxAggSize,
-                           const LWGraph_kokkos& graph,
-                           Aggregates_kokkos& aggregates,
-                           Kokkos::View<unsigned*, typename LWGraph_kokkos::memory_space>& aggStat,
-                           LO& numNonAggregatedNodes) const
+  BuildAggregatesRandom(const LO maxAggSize,
+                        const LWGraph_kokkos& graph,
+                        Aggregates_kokkos& aggregates,
+                        Kokkos::View<unsigned*, typename LWGraph_kokkos::memory_space>& aggStat,
+                        LO& numNonAggregatedNodes) const
   {
     using memory_space    = typename LWGraph_kokkos::memory_space;
     using execution_space = typename LWGraph_kokkos::execution_space;
@@ -312,21 +122,26 @@ namespace MueLu {
     auto procWinner   = aggregates.GetProcWinner()  ->template getLocalView<memory_space>();
     auto colors       = aggregates.GetGraphColors();
 
+    LO numAggregatedNodes = 0;
     LO numLocalAggregates = aggregates.GetNumAggregates();
     Kokkos::View<LO, memory_space> aggCount("aggCount");
-    LO tmpNumLocalAggregates = 0;
-    Kokkos::parallel_reduce("Aggregation Phase 1: initial reduction over color == 1",
-			    Kokkos::RangePolicy<execution_space>(0, numRows),
-                            KOKKOS_LAMBDA (const LO i, LO& lnumLocalAggregates) {
-                              if(colors(i) == 1 && aggStat(i) == READY) {
-                                const LO idx = Kokkos::atomic_fetch_add (&aggCount(), 1);
-                                vertex2AggId(i, 0) = idx;
-                                aggStat(i) = AGGREGATED;
-                                ++lnumLocalAggregates;
-                                procWinner(i, 0) = myRank;
-                              }
-                            }, tmpNumLocalAggregates);
-    numLocalAggregates += tmpNumLocalAggregates;
+    Kokkos::deep_copy(aggCount, numLocalAggregates);
+    Kokkos::parallel_for("Aggregation Phase 1: initial reduction over color == 1",
+                         Kokkos::RangePolicy<LO, execution_space>(0, numRows),
+                         KOKKOS_LAMBDA (const LO nodeIdx) {
+                           if(colors(nodeIdx) == 1 && aggStat(nodeIdx) == READY) {
+                             const LO aggIdx = Kokkos::atomic_fetch_add (&aggCount(), 1);
+                             vertex2AggId(nodeIdx, 0) = aggIdx;
+                             aggStat(nodeIdx) = AGGREGATED;
+                             procWinner(nodeIdx, 0) = myRank;
+                           }
+                         });
+    // Truely we wish to compute: numAggregatedNodes = aggCount - numLocalAggregates
+    // before updating the value of numLocalAggregates.
+    // But since we also do not want to create a host mirror of aggCount we do some trickery...
+    numAggregatedNodes -= numLocalAggregates;
+    Kokkos::deep_copy(numLocalAggregates, aggCount);
+    numAggregatedNodes += numLocalAggregates;
 
     // Compute the initial size of the aggregates.
     // Note lbv 12-21-17: I am pretty sure that the aggregates will always be of size 1
@@ -338,23 +153,24 @@ namespace MueLu {
       // to the same aggregate if somethings happened before phase 1?
       auto aggSizesScatterView = Kokkos::Experimental::create_scatter_view(aggSizesView);
       Kokkos::parallel_for("Aggregation Phase 1: compute initial aggregates size",
-			   Kokkos::RangePolicy<execution_space>(0, numRows),
-                           KOKKOS_LAMBDA (const LO i) {
+			   Kokkos::RangePolicy<LO, execution_space>(0, numRows),
+                           KOKKOS_LAMBDA (const LO nodeIdx) {
                              auto aggSizesScatterViewAccess = aggSizesScatterView.access();
-                             if(vertex2AggId(i, 0) >= 0)
-                               aggSizesScatterViewAccess(vertex2AggId(i, 0)) += 1;
+                             if(vertex2AggId(nodeIdx, 0) >= 0)
+                               aggSizesScatterViewAccess(vertex2AggId(nodeIdx, 0)) += 1;
                            });
       Kokkos::Experimental::contribute(aggSizesView, aggSizesScatterView);
     }
 
+    LO tmpNumAggregatedNodes = 0;
     Kokkos::parallel_reduce("Aggregation Phase 1: main parallel_reduce over aggSizes",
-			    Kokkos::RangePolicy<execution_space>(0, numRows),
-                            KOKKOS_LAMBDA (const size_t i, LO & lNumNonAggregatedNodes) {
-                              if(colors(i) != 1
-                                 && (aggStat(i) == READY || aggStat(i) == NOTSEL)) {
+			    Kokkos::RangePolicy<size_t, execution_space>(0, numRows),
+                            KOKKOS_LAMBDA (const size_t nodeIdx, LO & lNumAggregatedNodes) {
+                              if(colors(nodeIdx) != 1
+                                 && (aggStat(nodeIdx) == READY || aggStat(nodeIdx) == NOTSEL)) {
                                 // Get neighbors of vertex i and look for local, aggregated,
                                 // color 1 neighbor (valid root).
-                                auto neighbors = graph.getNeighborVertices(i);
+                                auto neighbors = graph.getNeighborVertices(nodeIdx);
                                 for(LO j = 0; j < neighbors.length; ++j) {
                                   auto nei = neighbors.colidx(j);
                                   if(graph.isLocalNeighborVertex(nei) && colors(nei) == 1
@@ -367,9 +183,10 @@ namespace MueLu {
                                                                                  1);
                                     if(aggSize < maxAggSize) {
                                       //assign vertex i to aggregate with root j
-                                      vertex2AggId(i, 0) = agg;
-                                      procWinner(i, 0)   = myRank;
-                                      aggStat(i)         = AGGREGATED;
+                                      vertex2AggId(nodeIdx, 0) = agg;
+                                      procWinner(nodeIdx, 0)   = myRank;
+                                      aggStat(nodeIdx)         = AGGREGATED;
+                                      ++lNumAggregatedNodes;
                                       break;
                                     } else {
                                       // Decrement back the value of aggSizesView(agg)
@@ -378,11 +195,13 @@ namespace MueLu {
                                   }
                                 }
                               }
-                              if(aggStat(i) != AGGREGATED) {
-                                lNumNonAggregatedNodes++;
-                                if(aggStat(i) == NOTSEL) { aggStat(i) = READY; }
-                              }
-                            }, numNonAggregatedNodes);
+                              // if(aggStat(nodeIdx) != AGGREGATED) {
+                              //   lNumNonAggregatedNodes++;
+                              if(aggStat(nodeIdx) == NOTSEL) { aggStat(nodeIdx) = READY; }
+                              // }
+                            }, tmpNumAggregatedNodes);
+    numAggregatedNodes += tmpNumAggregatedNodes;
+    numNonAggregatedNodes -= numAggregatedNodes;
 
     // update aggregate object
     aggregates.SetNumAggregates(numLocalAggregates);
@@ -469,19 +288,6 @@ namespace MueLu {
     aggregates.SetNumAggregates(numLocalAggregates + h_numNewRoots());
   }
 
-  template <class LocalOrdinal, class GlobalOrdinal, class Node>
-  void AggregationPhase1Algorithm_kokkos<LocalOrdinal, GlobalOrdinal, Node>::RandomReorder(ArrayRCP<LO> list) const {
-    //TODO: replace int
-    int n = list.size();
-    for(int i = 0; i < n-1; i++)
-      std::swap(list[i], list[RandomOrdinal(i,n-1)]);
-  }
-
-  template <class LocalOrdinal, class GlobalOrdinal, class Node>
-  int AggregationPhase1Algorithm_kokkos<LocalOrdinal, GlobalOrdinal, Node>::RandomOrdinal(int min, int max) const {
-    return min + as<int>((max-min+1) * (static_cast<double>(std::rand()) / (RAND_MAX + 1.0)));
-  }
-
 } // end namespace
 
 #endif // HAVE_MUELU_KOKKOS_REFACTOR
diff --git a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_PreserveDirichletAggregationAlgorithm_kokkos_def.hpp b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_PreserveDirichletAggregationAlgorithm_kokkos_def.hpp
index 3999dc9face5..51ddfa947e46 100644
--- a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_PreserveDirichletAggregationAlgorithm_kokkos_def.hpp
+++ b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_PreserveDirichletAggregationAlgorithm_kokkos_def.hpp
@@ -67,49 +67,56 @@ namespace MueLu {
   BuildAggregates(Teuchos::ParameterList const & params,
                   LWGraph_kokkos const & graph,
                   Aggregates_kokkos & aggregates,
-                  Kokkos::View<unsigned*, typename LWGraph_kokkos::memory_space>& aggstat,
+                  Kokkos::View<unsigned*, typename LWGraph_kokkos::memory_space>& aggStat,
                   LO& numNonAggregatedNodes) const {
     Monitor m(*this, "BuildAggregates");
-
-    typename Kokkos::View<unsigned*, memory_space>::HostMirror aggstatHost
-      = Kokkos::create_mirror(aggstat);
-    Kokkos::deep_copy(aggstatHost, aggstat);
-    std::vector<unsigned> aggStat;
-    aggStat.resize(aggstatHost.extent(0));
-    for(size_t idx = 0; idx < aggstatHost.extent(0); ++idx) {
-      aggStat[idx] = aggstatHost(idx);
+    using memory_space       = typename LWGraph_kokkos::memory_space;
+    using execution_space    = typename LWGraph_kokkos::execution_space;
+    using local_ordinal_type = typename LWGraph_kokkos::local_ordinal_type;
+
+    // Extract parameters and data from:
+    // 1) the parameter list
+    const bool preserve = params.get<bool>("aggregation: preserve Dirichlet points");
+
+    // 2) the amalgamated graph
+    const LO  numNodes  = graph.GetNodeNumVertices();
+    const int myRank    = graph.GetComm()->getRank();
+
+    // 3) the aggregates
+    auto vertex2AggId   = aggregates.GetVertex2AggId()->template getLocalView<memory_space>();
+    auto procWinner     = aggregates.GetProcWinner()  ->template getLocalView<memory_space>();
+
+    // A view is needed to count on the fly the current number of local aggregates
+    Kokkos::View<LO, memory_space> aggCount("aggCount");
+    if(preserve) {
+      Kokkos::deep_copy(aggCount, aggregates.GetNumAggregates());
     }
-
-    bool preserve = params.get<bool>("aggregation: preserve Dirichlet points");
-
-    const LO  numRows = graph.GetNodeNumVertices();
-    const int myRank  = graph.GetComm()->getRank();
-
-    ArrayRCP<LO> vertex2AggId = aggregates.GetVertex2AggId()->getDataNonConst(0);
-    ArrayRCP<LO> procWinner   = aggregates.GetProcWinner()  ->getDataNonConst(0);
-
-    LO numLocalAggregates = aggregates.GetNumAggregates();
-
-    for (LO i = 0; i < numRows; i++)
-      if (aggStat[i] == BOUNDARY) {
-        aggStat[i] = IGNORED;
-        numNonAggregatedNodes--;
-
-        if (preserve) {
-          aggregates.SetIsRoot(i);
-
-          vertex2AggId[i] = numLocalAggregates++;
-          procWinner  [i] = myRank;
-        }
-      }
-
-    for(size_t idx = 0; idx < aggstatHost.extent(0); ++idx) {
-      aggstatHost(idx) = aggStat[idx];
-    }
-    Kokkos::deep_copy(aggstat, aggstatHost);
+    Kokkos::parallel_for("MueLu - PreserveDirichlet: tagging ignored nodes",
+                         Kokkos::RangePolicy<local_ordinal_type, execution_space>(0, numNodes),
+                         KOKKOS_LAMBDA(const local_ordinal_type nodeIdx) {
+                           if (aggStat(nodeIdx) == BOUNDARY) {
+                             aggStat(nodeIdx) = IGNORED;
+                             const LO aggIdx = Kokkos::atomic_fetch_add(&aggCount(), 1);
+
+                             if (preserve) {
+                               // aggregates.SetIsRoot(nodeIdx);
+
+                               vertex2AggId(nodeIdx, 0) = aggIdx;
+                               procWinner(nodeIdx, 0)   = myRank;
+                             }
+                           }
+                         });
+    typename Kokkos::View<LO, memory_space>::HostMirror aggCount_h
+      = Kokkos::create_mirror_view(aggCount);
+    Kokkos::deep_copy(aggCount_h, aggCount);
+    // In this phase the number of new aggregates is the same
+    // as the number of newly aggregated nodes.
+    numNonAggregatedNodes -= (aggCount_h() - aggregates.GetNumAggregates());
 
     // update aggregate object
-    aggregates.SetNumAggregates(numLocalAggregates);
+    if(preserve) {
+      aggregates.SetNumAggregates(aggCount_h());
+    }
   }
 
 } // end namespace
diff --git a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_UncoupledAggregationFactory_kokkos_def.hpp b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_UncoupledAggregationFactory_kokkos_def.hpp
index 47abc4b44965..b928eaab2d5c 100644
--- a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_UncoupledAggregationFactory_kokkos_def.hpp
+++ b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_UncoupledAggregationFactory_kokkos_def.hpp
@@ -99,9 +99,9 @@ namespace MueLu {
     SET_VALID_ENTRY("aggregation: ordering");
     validParamList->getEntry("aggregation: ordering").setValidator(
       rcp(new validatorType(Teuchos::tuple<std::string>("natural", "graph", "random"), "aggregation: ordering")));
-    SET_VALID_ENTRY("aggregation: enable phase 1");
-    SET_VALID_ENTRY("aggregation: phase 1 algorithm");
     SET_VALID_ENTRY("aggregation: deterministic");
+    SET_VALID_ENTRY("aggregation: coloring algorithm");
+    SET_VALID_ENTRY("aggregation: enable phase 1");
     SET_VALID_ENTRY("aggregation: enable phase 2a");
     SET_VALID_ENTRY("aggregation: enable phase 2b");
     SET_VALID_ENTRY("aggregation: enable phase 3");
@@ -142,7 +142,11 @@ namespace MueLu {
   }
 
   template <class LocalOrdinal, class GlobalOrdinal, class Node>
-  void UncoupledAggregationFactory_kokkos<LocalOrdinal, GlobalOrdinal, Node>::Build(Level &currentLevel) const {
+  void UncoupledAggregationFactory_kokkos<LocalOrdinal, GlobalOrdinal, Node>::
+  Build(Level &currentLevel) const {
+    using execution_space    = typename LWGraph_kokkos::execution_space;
+    using memory_space       = typename LWGraph_kokkos::memory_space;
+    using local_ordinal_type = typename LWGraph_kokkos::local_ordinal_type;
     FactoryMonitor m(*this, "Build", currentLevel);
 
     ParameterList pL = GetParameterList();
@@ -197,17 +201,14 @@ namespace MueLu {
     // getLocalMap to have a Kokkos::View on the appropriate memory_space
     // instead of an ArrayRCP.
     {
-      auto dirichletBoundaryMap = graph->GetBoundaryNodeMap();
-
-      typename Kokkos::View<unsigned*,typename LWGraph_kokkos::memory_space>::HostMirror aggStatHost
-        = Kokkos::create_mirror_view(aggStat);
-      Kokkos::deep_copy(aggStatHost, aggStat);
-
-      for (LO i = 0; i < numRows; i++)
-        if (dirichletBoundaryMap(i) == true)
-          aggStatHost(i) = BOUNDARY;
-
-      Kokkos::deep_copy(aggStat, aggStatHost);
+      typename LWGraph_kokkos::boundary_nodes_type dirichletBoundaryMap = graph->GetBoundaryNodeMap();
+      Kokkos::parallel_for("MueLu - UncoupledAggregation: tagging boundary nodes in aggStat",
+                           Kokkos::RangePolicy<local_ordinal_type, execution_space>(0, numRows),
+                           KOKKOS_LAMBDA(const local_ordinal_type nodeIdx) {
+                             if (dirichletBoundaryMap(nodeIdx) == true) {
+                               aggStat(nodeIdx) = BOUNDARY;
+                             }
+                           });
     }
 
     LO nDofsPerNode = Get<LO>(currentLevel, "DofsPerNode");
@@ -267,7 +268,16 @@ namespace MueLu {
       //     COLORING_D2_VB             - Use the parallel vertex based direct method
       //     COLORING_D2_VB_BIT         - Same as VB but using the bitvector forbidden array
       //     COLORING_D2_VB_BIT_EF      - Add experimental edge-filtering to VB_BIT
-      coloringHandle->set_algorithm( KokkosGraph::COLORING_D2_SERIAL );
+      if(pL.get<bool>("aggregation: deterministic") == true) {
+        coloringHandle->set_algorithm( KokkosGraph::COLORING_D2_SERIAL );
+      } else {
+        // Note: LBV on 2019-11-19
+        // I would really like to set this to COLORING_D2_DEFAULT
+        // unless pL.get<std::string>("aggregation: coloring algorithm")
+        // is set which would trigger a specific algorithm being used...
+        // We first need to test the coloring algorithms a bit more!
+        coloringHandle->set_algorithm( KokkosGraph::COLORING_D2_SERIAL );
+      }
 
       //Create device views for graph rowptrs/colinds
       typename graph_t::row_map_type aRowptrs = graph->getRowPtrs();
@@ -285,6 +295,10 @@ namespace MueLu {
 
       //clean up coloring handle
       kh.destroy_distance2_graph_coloring_handle();
+
+      if (IsPrint(Statistics1)) {
+        GetOStream(Statistics1) << "  num colors: " << aggregates->GetGraphNumColors() << std::endl;
+      }
     }
 
     LO numNonAggregatedNodes = numRows;
diff --git a/packages/muelu/src/MueCentral/MueLu_MasterList.cpp b/packages/muelu/src/MueCentral/MueLu_MasterList.cpp
index 6ff8232f8b0a..f9fd5c94a758 100644
--- a/packages/muelu/src/MueCentral/MueLu_MasterList.cpp
+++ b/packages/muelu/src/MueCentral/MueLu_MasterList.cpp
@@ -197,7 +197,7 @@ namespace MueLu {
   "<Parameter name=\"aggregation: max selected neighbors\" type=\"int\" value=\"0\"/>"
   "<Parameter name=\"aggregation: Dirichlet threshold\" type=\"double\" value=\"0.0\"/>"
   "<Parameter name=\"aggregation: deterministic\" type=\"bool\" value=\"false\"/>"
-  "<Parameter name=\"aggregation: phase 1 algorithm\" type=\"string\" value=\"Serial\"/>"
+  "<Parameter name=\"aggregation: coloring algorithm\" type=\"string\" value=\"default\"/>"
   "<Parameter name=\"aggregation: enable phase 1\" type=\"bool\" value=\"true\"/>"
   "<Parameter name=\"aggregation: enable phase 2a\" type=\"bool\" value=\"true\"/>"
   "<Parameter name=\"aggregation: enable phase 2b\" type=\"bool\" value=\"true\"/>"
@@ -562,7 +562,7 @@ namespace MueLu {
       
          ("aggregation: deterministic","aggregation: deterministic")
       
-         ("aggregation: phase 1 algorithm","aggregation: phase 1 algorithm")
+         ("aggregation: coloring algorithm","aggregation: coloring algorithm")
       
          ("aggregation: enable phase 1","aggregation: enable phase 1")
       
diff --git a/packages/muelu/test/unit_tests/RegionMatrix.cpp b/packages/muelu/test/unit_tests/RegionMatrix.cpp
index c10c198f227f..561d13a4a06e 100644
--- a/packages/muelu/test/unit_tests/RegionMatrix.cpp
+++ b/packages/muelu/test/unit_tests/RegionMatrix.cpp
@@ -246,7 +246,9 @@ void test_matrix(const int maxRegPerProc,
   ArrayRCP<const SC> dataB     = B->getData(0);
   ArrayRCP<const SC> dataCompB = compB->getData(0);
   for(size_t idx = 0; idx < B->getLocalLength(); ++idx) {
-    TEST_FLOATING_EQUALITY(dataB[idx], dataCompB[idx], 100*TMT::eps());
+    TEST_FLOATING_EQUALITY(TST::magnitude(dataB[idx]),
+                           TST::magnitude(dataCompB[idx]),
+                           100*TMT::eps());
   }
 
 
@@ -291,7 +293,9 @@ void test_matrix(const int maxRegPerProc,
   TEST_EQUALITY(compositeValues_h.extent(0),  refValues_h.extent(0));
   for(LO idx = 0; idx < compositeEntries_h.extent_int(0); ++idx) {
     TEST_EQUALITY(compositeEntries_h(idx), refEntries(idx));
-    TEST_FLOATING_EQUALITY(compositeValues_h(idx), refValues_h(idx), 100*TMT::eps());
+    TEST_FLOATING_EQUALITY(TST::magnitude(compositeValues_h(idx)),
+                           TST::magnitude(refValues_h(idx)),
+                           100*TMT::eps());
   }
 } // test_matrix
 
@@ -391,7 +395,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, CompositeToRegionMatrix, Scalar,
 
     for(int idx = 0; idx < 105; ++idx) {
       TEST_EQUALITY(myEntries_h(idx), refEntries_h(idx));
-      TEST_FLOATING_EQUALITY(myValues_h(idx),  refValues_h(idx), 100*TMT::eps());
+      TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                             TST::magnitude(refValues_h(idx)),
+                             100*TMT::eps());
     }
   } else if(numRanks == 4) {
     // All ranks will have the same number of rows/cols/entries
@@ -460,7 +466,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, CompositeToRegionMatrix, Scalar,
     // Loop over region matrix data and compare it to ref data
     for(int idx = 0; idx < 33; ++idx) {
       TEST_EQUALITY(myEntries_h(idx), refEntries[idx]);
-      TEST_FLOATING_EQUALITY(myValues_h(idx), refValues[idx], 100*TMT::eps());
+      TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                             TST::magnitude(refValues[idx]),
+                             100*TMT::eps());
     }
   }
 
@@ -567,7 +575,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, RegionToCompositeMatrix, Scalar,
   TEST_EQUALITY(compositeValues_h.extent(0),  refValues_h.extent(0));
   for(LO idx = 0; idx < compositeEntries_h.extent_int(0); ++idx) {
     TEST_EQUALITY(compositeEntries_h(idx), refEntries(idx));
-    TEST_FLOATING_EQUALITY(compositeValues_h(idx), refValues_h(idx), 100*TMT::eps());
+    TEST_FLOATING_EQUALITY(TST::magnitude(compositeValues_h(idx)),
+                           TST::magnitude(refValues_h(idx)),
+                           100*TMT::eps());
   }
 
 } // RegionToCompositeMatrix
@@ -661,7 +671,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, MatVec, Scalar, LocalOrdinal, Gl
   ArrayRCP<const SC> dataB     = B->getData(0);
   ArrayRCP<const SC> dataCompB = compB->getData(0);
   for(size_t idx = 0; idx < B->getLocalLength(); ++idx) {
-    TEST_FLOATING_EQUALITY(dataB[idx], dataCompB[idx], 100*TMT::eps());
+    TEST_FLOATING_EQUALITY(TST::magnitude(dataB[idx]),
+                           TST::magnitude(dataCompB[idx]),
+                           100*TMT::eps());
   }
 
 } // MatVec
@@ -760,7 +772,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace2D, Scalar, LocalOrdinal,
 
     for(int idx = 0; idx < 128; ++idx) {
       TEST_EQUALITY(myEntries_h(idx), refEntries_h(idx));
-      TEST_FLOATING_EQUALITY(myValues_h(idx),  refValues_h(idx), 100*TMT::eps());
+      TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                             TST::magnitude(refValues_h(idx)),
+                             100*TMT::eps());
     }
   } else if(numRanks == 4) {
     // All ranks will have the same number of rows/cols/entries
@@ -830,7 +844,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace2D, Scalar, LocalOrdinal,
 
     // Loop over region matrix data and compare it to ref data
     for(int idx = 0; idx < 33; ++idx) {
-      TEST_FLOATING_EQUALITY(myValues_h(idx), refValues[idx], 100*TMT::eps());
+      TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                             TST::magnitude(refValues[idx]),
+                             100*TMT::eps());
     }
   }
 } // Laplace2D
@@ -930,7 +946,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace3D, Scalar, LocalOrdinal,
 
     for(int idx = 0; idx < refEntries_h.extent_int(0); ++idx) {
       TEST_EQUALITY(myEntries_h(idx), refEntries_h(idx));
-      TEST_FLOATING_EQUALITY(myValues_h(idx),  refValues_h(idx), 100*TMT::eps());
+      TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                             TST::magnitude(refValues_h(idx)),
+                             100*TMT::eps());
     }
   } else if(numRanks == 4) {
     // All ranks will have the same number of rows/cols/entries
@@ -981,7 +999,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace3D, Scalar, LocalOrdinal,
 
       // Loop over region matrix data and compare it to ref data
       for(int idx = 0; idx < 186; ++idx) {
-        TEST_FLOATING_EQUALITY(myValues_h(idx), refValues[idx], 100*TMT::eps());
+        TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                               TST::magnitude(refValues[idx]),
+                               100*TMT::eps());
       }
 
     } else if(myRank == 1) {
@@ -1038,7 +1058,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace3D, Scalar, LocalOrdinal,
 
       // Loop over region matrix data and compare it to ref data
       for(int idx = 0; idx < 256; ++idx) {
-        TEST_FLOATING_EQUALITY(myValues_h(idx), refValues[idx], 100*TMT::eps());
+        TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                               TST::magnitude(refValues[idx]),
+                               100*TMT::eps());
       }
 
     } else if(myRank == 2) {
@@ -1083,7 +1105,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace3D, Scalar, LocalOrdinal,
 
       // Loop over region matrix data and compare it to ref data
       for(int idx = 0; idx < 186; ++idx) {
-        TEST_FLOATING_EQUALITY(myValues_h(idx), refValues[idx], 100*TMT::eps());
+        TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                               TST::magnitude(refValues[idx]),
+                               100*TMT::eps());
       }
 
     } else if(myRank == 3) {
@@ -1140,7 +1164,9 @@ TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(RegionMatrix, Laplace3D, Scalar, LocalOrdinal,
 
       // Loop over region matrix data and compare it to ref data
       for(int idx = 0; idx < 256; ++idx) {
-        TEST_FLOATING_EQUALITY(myValues_h(idx), refValues[idx], 100*TMT::eps());
+        TEST_FLOATING_EQUALITY(TST::magnitude(myValues_h(idx)),
+                               TST::magnitude(refValues[idx]),
+                               100*TMT::eps());
       }
     }
   }
diff --git a/packages/muelu/test/unit_tests_kokkos/Aggregates_kokkos.cpp b/packages/muelu/test/unit_tests_kokkos/Aggregates_kokkos.cpp
index e8fb277d0a1c..42078ce2634c 100644
--- a/packages/muelu/test/unit_tests_kokkos/Aggregates_kokkos.cpp
+++ b/packages/muelu/test/unit_tests_kokkos/Aggregates_kokkos.cpp
@@ -46,6 +46,10 @@
 #include <Teuchos_UnitTestHarness.hpp>
 #include <Teuchos_DefaultComm.hpp>
 
+#include "Kokkos_StaticCrsGraph.hpp"
+#include "KokkosGraph_Distance2ColorHandle.hpp"
+#include "KokkosGraph_Distance2Color.hpp"
+
 #include <Xpetra_Matrix.hpp>
 
 #include "MueLu_TestHelpers_kokkos.hpp"
@@ -53,6 +57,10 @@
 
 #include "MueLu_Level.hpp"
 #include "MueLu_Aggregates_kokkos.hpp"
+#include "MueLu_AggregationPhase1Algorithm_kokkos.hpp"
+#include "MueLu_AggregationPhase2aAlgorithm_kokkos.hpp"
+#include "MueLu_AggregationPhase2bAlgorithm_kokkos.hpp"
+#include "MueLu_AggregationPhase3Algorithm_kokkos.hpp"
 #include "MueLu_AmalgamationInfo_kokkos.hpp"
 #include "MueLu_AmalgamationFactory_kokkos.hpp"
 #include "MueLu_CoalesceDropFactory_kokkos.hpp"
@@ -65,14 +73,12 @@ namespace MueLuTests {
 
   // Little utility to generate uncoupled aggregates.
   template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
-  Teuchos::RCP<MueLu::Aggregates_kokkos<LocalOrdinal, GlobalOrdinal, Node>>
-  gimmeUncoupledAggregates(const Teuchos::RCP<Xpetra::Matrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>>& A,
-                           Teuchos::RCP<MueLu::AmalgamationInfo_kokkos<LocalOrdinal, GlobalOrdinal, Node>>& amalgInfo,
-                           bool bPhase1 = true, bool bPhase2a = true, bool bPhase2b = true, bool bPhase3 = true) {
+  void gimmeUncoupledAggregates_kokkos(const Teuchos::RCP<Xpetra::Matrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >& A,
+                                       RCP<MueLu::LWGraph_kokkos<LocalOrdinal, GlobalOrdinal, Node> >& graph,
+                                       Teuchos::RCP<MueLu::Aggregates_kokkos<LocalOrdinal, GlobalOrdinal, Node> >& aggregates,
+                                       bool bPhase1 = true, bool bPhase2a = true, bool bPhase2b = true, bool bPhase3 = true) {
 #   include "MueLu_UseShortNames.hpp"
-
     Level level;
-
     TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::createSingleLevelHierarchy(level);
     level.Set("A", A);
 
@@ -80,33 +86,145 @@ namespace MueLuTests {
     RCP<CoalesceDropFactory_kokkos> dropFact  = rcp(new CoalesceDropFactory_kokkos());
     dropFact->SetFactory("UnAmalgamationInfo", amalgFact);
 
-    using Teuchos::ParameterEntry;
+    level.Request("Graph", dropFact.get());
+    level.Request(*dropFact);
+    dropFact->Build(level);
+    graph = level.Get<RCP<LWGraph_kokkos> >("Graph", dropFact.get());
+    const LO numNodes = graph->GetNodeNumVertices();
+    aggregates = rcp(new Aggregates_kokkos(*graph));
+    aggregates->setObjectLabel("UC");
+
+    using graph_t = typename LWGraph_kokkos::local_graph_type;
+    using KernelHandle = KokkosKernels::Experimental::
+      KokkosKernelsHandle<typename graph_t::row_map_type::value_type,
+                          typename graph_t::entries_type::value_type,
+                          typename graph_t::entries_type::value_type,
+                          typename graph_t::device_type::execution_space,
+                          typename graph_t::device_type::memory_space,
+                          typename graph_t::device_type::memory_space>;
+    KernelHandle kh;
+    //leave gc algorithm choice as the default
+    kh.create_distance2_graph_coloring_handle();
+
+    // get the distance-2 graph coloring handle
+    auto coloringHandle = kh.get_distance2_graph_coloring_handle();
+    coloringHandle->set_algorithm( KokkosGraph::COLORING_D2_SERIAL );
+
+    //Create device views for graph rowptrs/colinds
+    typename graph_t::row_map_type aRowptrs = graph->getRowPtrs();
+    typename graph_t::entries_type aColinds = graph->getEntries();
+
+    //run d2 graph coloring
+    //graph is symmetric so row map/entries and col map/entries are the same
+    KokkosGraph::Experimental::graph_compute_distance2_color(&kh, numNodes, numNodes,
+                                                             aRowptrs, aColinds,
+                                                             aRowptrs, aColinds);
+
+    // extract the colors and store them in the aggregates
+    aggregates->SetGraphColors(coloringHandle->get_vertex_colors());
+    aggregates->SetGraphNumColors(static_cast<LO>(coloringHandle->get_num_colors()));
+
+    LO numNonAggregatedNodes = 0;
+    Kokkos::View<unsigned*, typename LWGraph_kokkos::memory_space> aggStat("aggStat", numNodes);
+    Kokkos::deep_copy(aggStat, MueLu::READY);
+    Teuchos::ParameterList params;
+    params.set<int> ("aggregation: min agg size", 1);
+    params.set<int> ("aggregation: max agg size", 3);
+    params.set<bool>("aggregation: deterministic", false);
+
+    if(bPhase1) {
+      RCP<MueLu::AggregationAlgorithmBase_kokkos<LO,GO,NO> > phase1
+        = rcp(new AggregationPhase1Algorithm_kokkos(dropFact));
+      phase1->BuildAggregates(params, *graph, *aggregates, aggStat, numNonAggregatedNodes);
+    }
+    if(bPhase2a) {
+      RCP<MueLu::AggregationAlgorithmBase_kokkos<LO,GO,NO> > phase2a
+        = rcp(new AggregationPhase2aAlgorithm_kokkos(dropFact));
+      phase2a->BuildAggregates(params, *graph, *aggregates, aggStat, numNonAggregatedNodes);
+    }
+    if(bPhase2b) {
+      RCP<MueLu::AggregationAlgorithmBase_kokkos<LO,GO,NO> > phase2b
+        = rcp(new AggregationPhase2bAlgorithm_kokkos(dropFact));
+      phase2b->BuildAggregates(params, *graph, *aggregates, aggStat, numNonAggregatedNodes);
+    }
+    if(bPhase3) {
+      RCP<MueLu::AggregationAlgorithmBase_kokkos<LO,GO,NO> > phase3
+        = rcp(new AggregationPhase3Algorithm_kokkos(dropFact));
+      phase3->BuildAggregates(params, *graph, *aggregates, aggStat, numNonAggregatedNodes);
+    }
+    aggregates->AggregatesCrossProcessors(false);
+    aggregates->ComputeAggregateSizes(true/*forceRecompute*/);
+    level.Release("Graph", dropFact.get());
+  }
 
-    // Setup aggregation factory (use default factory for graph)
-    RCP<UncoupledAggregationFactory_kokkos> aggFact = rcp(new UncoupledAggregationFactory_kokkos());
-    aggFact->SetFactory("Graph", dropFact);
-    aggFact->SetParameter("aggregation: max agg size",           ParameterEntry(3));
-    aggFact->SetParameter("aggregation: min agg size",           ParameterEntry(3));
-    aggFact->SetParameter("aggregation: max selected neighbors", ParameterEntry(0));
-    aggFact->SetParameter("aggregation: ordering",               ParameterEntry(std::string("natural")));
-    aggFact->SetParameter("aggregation: enable phase 1",         ParameterEntry(bPhase1));
-    aggFact->SetParameter("aggregation: enable phase 2a",        ParameterEntry(bPhase2a));
-    aggFact->SetParameter("aggregation: enable phase 2b",        ParameterEntry(bPhase2b));
-    aggFact->SetParameter("aggregation: enable phase 3",         ParameterEntry(bPhase3));
-
-    level.Request("Aggregates",         aggFact.get());
-    level.Request("UnAmalgamationInfo", amalgFact.get());
+  // Little utility to generate uncoupled aggregates.
+  template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
+  Teuchos::RCP<MueLu::Aggregates_kokkos<LocalOrdinal, GlobalOrdinal, Node> >
+  gimmeUncoupledAggregates_kokkos(const Teuchos::RCP<Xpetra::Matrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >& A,
+                                  bool bPhase1 = true, bool bPhase2a = true, bool bPhase2b = true, bool bPhase3 = true) {
+#   include "MueLu_UseShortNames.hpp"
+    RCP<LWGraph_kokkos> graph;
+    RCP<Aggregates_kokkos> aggregates;
 
-    level.Request(*aggFact);
-    aggFact->Build(level);
+    gimmeUncoupledAggregates_kokkos(A, graph, aggregates, bPhase1, bPhase2a, bPhase2b, bPhase3);
 
-    auto aggregates = level.Get<RCP<Aggregates_kokkos> >("Aggregates", aggFact.get());
-    amalgInfo = level.Get<RCP<AmalgamationInfo_kokkos> >("UnAmalgamationInfo", amalgFact.get());
-    level.Release("UnAmalgamationInfo", amalgFact.get());
-    level.Release("Aggregates",         aggFact.get());
     return aggregates;
   }
 
+  template <class LocalOrdinal, class GlobalOrdinal, class Node>
+  LocalOrdinal checkAggregatesContiguous(MueLu::LWGraph_kokkos<LocalOrdinal, GlobalOrdinal, Node> graph,
+                                         MueLu::Aggregates_kokkos<LocalOrdinal, GlobalOrdinal, Node> aggregates) {
+    using LO = LocalOrdinal;
+    using GO = GlobalOrdinal;
+    using Aggregates_kokkos = MueLu::Aggregates_kokkos<LO, GO, Node>;
+    using LWGraph_kokkos    = MueLu::LWGraph_kokkos<LO, GO, Node>;
+    using execution_space   = typename LWGraph_kokkos::execution_space;
+    using memory_space      = typename LWGraph_kokkos::memory_space;
+
+    const LO numNodes = graph.GetNodeNumVertices();
+    auto vertex2AggId = aggregates.GetVertex2AggId()->template getLocalView<memory_space>();
+    auto aggSizes     = aggregates.ComputeAggregateSizes(true);
+
+    Kokkos::View<LO*, memory_space> discontiguousAggs("discontiguous aggregates",
+                                                      aggregates.GetNumAggregates());
+    Kokkos::parallel_for("Mark discontiguous aggregates",
+                         Kokkos::RangePolicy<LO, execution_space>(0, numNodes),
+                         KOKKOS_LAMBDA(const LO nodeIdx) {
+                           const LO myAggId   = vertex2AggId(nodeIdx, 0);
+                           // Check that the node is actually aggregated
+                           if(myAggId == -1) {return;}
+                           const LO myAggSize = aggSizes(myAggId);
+
+                           if(myAggSize == 1) {
+                             // Can't have a discontiguous singleton
+                             return;
+                           } else {
+                             auto neighbors = graph.getNeighborVertices(nodeIdx);
+                             for(LO neigh = 0; neigh < neighbors.length; ++neigh) {
+                               const LO neighIdx   = neighbors(neigh);
+                               const LO neighAggId = vertex2AggId(neighIdx, 0);
+                               if((nodeIdx != neighIdx) && (neighAggId == myAggId)) {
+                                 // This aggregate might be discontiguous
+                                 // but at least not because of this node
+                                 return;
+                               }
+                             }
+                             discontiguousAggs(myAggId) = 1;
+                           }
+                         });
+
+    LO numDiscontiguousAggregates = 0;
+    Kokkos::parallel_reduce("Count discontiguous aggregates",
+                            Kokkos::RangePolicy<LO, execution_space>(0, aggregates.GetNumAggregates()),
+                            KOKKOS_LAMBDA(const LO aggIdx, LO& numDiscontiguous) {
+                              if(discontiguousAggs(aggIdx) == 1) {
+                                ++numDiscontiguous;
+                              }
+                            }, numDiscontiguousAggregates);
+
+    return numDiscontiguousAggregates;
+  }
+
   TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Aggregates_kokkos, JustUncoupledAggregation, Scalar, LocalOrdinal, GlobalOrdinal, Node)
   {
 #   include "MueLu_UseShortNames.hpp"
@@ -116,8 +234,7 @@ namespace MueLuTests {
 
     RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::Build1DPoisson(15);
 
-    RCP<AmalgamationInfo_kokkos> amalgInfo;
-    RCP<Aggregates_kokkos> aggregates = gimmeUncoupledAggregates(A, amalgInfo);
+    RCP<Aggregates_kokkos> aggregates = gimmeUncoupledAggregates_kokkos(A);
 
     TEST_EQUALITY(aggregates != Teuchos::null,              true);
     TEST_EQUALITY(aggregates->AggregatesCrossProcessors(),  false);
@@ -147,9 +264,7 @@ namespace MueLuTests {
     aggFact->SetParameter("aggregation: max agg size",           Teuchos::ParameterEntry(3));
     aggFact->SetParameter("aggregation: min agg size",           Teuchos::ParameterEntry(3));
     aggFact->SetParameter("aggregation: max selected neighbors", Teuchos::ParameterEntry(0));
-    aggFact->SetParameter("aggregation: ordering",               Teuchos::ParameterEntry(std::string("natural")));
     aggFact->SetParameter("aggregation: enable phase 1",         Teuchos::ParameterEntry(true));
-    aggFact->SetParameter("aggregation: phase 1 algorithm",      Teuchos::ParameterEntry(std::string("Distance2")));
     aggFact->SetParameter("aggregation: enable phase 2a",        Teuchos::ParameterEntry(true));
     aggFact->SetParameter("aggregation: enable phase 2b",        Teuchos::ParameterEntry(true));
     aggFact->SetParameter("aggregation: enable phase 3",         Teuchos::ParameterEntry(true));
@@ -191,10 +306,8 @@ namespace MueLuTests {
     aggFact->SetParameter("aggregation: max agg size",           Teuchos::ParameterEntry(3));
     aggFact->SetParameter("aggregation: min agg size",           Teuchos::ParameterEntry(3));
     aggFact->SetParameter("aggregation: max selected neighbors", Teuchos::ParameterEntry(0));
-    aggFact->SetParameter("aggregation: ordering",               Teuchos::ParameterEntry(std::string("natural")));
     aggFact->SetParameter("aggregation: deterministic",          Teuchos::ParameterEntry(true));
     aggFact->SetParameter("aggregation: enable phase 1",         Teuchos::ParameterEntry(true));
-    aggFact->SetParameter("aggregation: phase 1 algorithm",      Teuchos::ParameterEntry(std::string("Distance2")));
     aggFact->SetParameter("aggregation: enable phase 2a",        Teuchos::ParameterEntry(true));
     aggFact->SetParameter("aggregation: enable phase 2b",        Teuchos::ParameterEntry(true));
     aggFact->SetParameter("aggregation: enable phase 3",         Teuchos::ParameterEntry(true));
@@ -212,63 +325,71 @@ namespace MueLuTests {
     level.Release("Aggregates", aggFact.get());
   }
 
-  ///////////////////////////////////////////////////////////////////////////
 
-  TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Aggregates_kokkos, GetNumUncoupledAggregates, Scalar, LocalOrdinal, GlobalOrdinal, Node)
+// A test that creates discontiguous aggregates to make sure the detection algorithm works well
+/// pretty much testing the test...
+  TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Aggregates_kokkos, DiscontiguousAggregates, Scalar, LocalOrdinal, GlobalOrdinal, Node)
   {
 #   include "MueLu_UseShortNames.hpp"
     MUELU_TESTING_SET_OSTREAM;
     MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,NO);
     out << "version: " << MueLu::Version() << std::endl;
 
+    using memory_space = typename Aggregates_kokkos::device_type::memory_space;
 
-    RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::Build1DPoisson(36);
-    RCP<const Map> rowmap = A->getRowMap();
-    RCP<AmalgamationInfo_kokkos> amalgInfo;
-    RCP<Aggregates_kokkos> aggregates = gimmeUncoupledAggregates(A, amalgInfo);
-    GO numAggs = aggregates->GetNumAggregates();
     RCP<const Teuchos::Comm<int> > comm = TestHelpers_kokkos::Parameters::getDefaultComm();
+    RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::Build1DPoisson(3*comm->getSize());
+    Level level;
+    TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::createSingleLevelHierarchy(level);
+    level.Set("A", A);
 
-    TEST_EQUALITY(aggregates->AggregatesCrossProcessors(),false);
+    RCP<Aggregates_kokkos> aggregates;
+    RCP<LWGraph_kokkos> graph;
+
+    RCP<AmalgamationFactory_kokkos> amalgFact = rcp(new AmalgamationFactory_kokkos());
+    RCP<CoalesceDropFactory_kokkos> dropFact  = rcp(new CoalesceDropFactory_kokkos());
+    dropFact->SetFactory("UnAmalgamationInfo", amalgFact);
+
+    level.Request("Graph", dropFact.get());
+    level.Request(*dropFact);
+    dropFact->Build(level);
+    graph = level.Get<RCP<LWGraph_kokkos> >("Graph", dropFact.get());
+    RCP<const Map> importMap = graph->GetImportMap();
+    const LO numNodes = graph->GetNodeNumVertices();
+    aggregates = rcp(new Aggregates_kokkos(*graph));
+    aggregates->setObjectLabel("UC");
+
+    Kokkos::View<unsigned*, typename LWGraph_kokkos::memory_space> aggStat("aggStat", numNodes);
+    Kokkos::deep_copy(aggStat, MueLu::READY);
+
+    // Performing fake aggregates to generate a discontiguous aggregate
+    Kokkos::View<LO**, Kokkos::LayoutLeft, memory_space> vertex2AggId = aggregates->GetVertex2AggId()->template getLocalView<memory_space>();
+    Kokkos::View<LO**, Kokkos::LayoutLeft, memory_space> procWinner   = aggregates->GetProcWinner()->template getLocalView<memory_space>();
+
+    typename Kokkos::View<LO**, Kokkos::LayoutLeft, memory_space>::HostMirror vertex2AggId_h
+      = Kokkos::create_mirror_view(vertex2AggId);
+    Kokkos::deep_copy(vertex2AggId_h, vertex2AggId);
+    vertex2AggId_h(0, 0) = 0;
+    vertex2AggId_h(1, 0) = 1;
+    vertex2AggId_h(2, 0) = 0;
+    Kokkos::deep_copy(vertex2AggId, vertex2AggId_h);
+
+    typename Kokkos::View<LO**, Kokkos::LayoutLeft, memory_space>::HostMirror procWinner_h
+      = Kokkos::create_mirror_view(procWinner);
+    Kokkos::deep_copy(procWinner_h, procWinner);
+    procWinner_h(0, 0) = comm->getRank();
+    procWinner_h(1, 0) = comm->getRank();
+    procWinner_h(2, 0) = comm->getRank();
+    Kokkos::deep_copy(procWinner, procWinner_h);
+
+    aggregates->SetNumAggregates(2);
+    aggregates->AggregatesCrossProcessors(false);
+    aggregates->ComputeAggregateSizes(true);
+
+    const LO numDiscontiguous = checkAggregatesContiguous(*graph, *aggregates);
+    TEST_EQUALITY(numDiscontiguous, 1);
+  } //UncoupledPhase1
 
-    auto aggSizes = aggregates->ComputeAggregateSizes(true);
-
-    bool foundAggNotSize3=false;
-    for (int i=0; i < as<int>(aggSizes.size()); ++i)
-      if (aggSizes[i] != 3) {
-        foundAggNotSize3=true;
-        break;
-      }
-
-    switch (comm->getSize()) {
-
-      case 1 :
-        TEST_EQUALITY(numAggs, 12);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      case 2:
-        TEST_EQUALITY(numAggs, 6);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      case 3:
-        TEST_EQUALITY(numAggs, 4);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      case 4:
-        TEST_EQUALITY(numAggs, 3);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      default:
-        std::string msg = "Only 1-4 MPI processes are supported.";
-        //throw(MueLu::Exceptions::NotImplemented(msg));
-        out << msg << std::endl;
-        break;
-    }
-  } //GetNumAggregates
 
   TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Aggregates_kokkos, UncoupledPhase1, Scalar, LocalOrdinal, GlobalOrdinal, Node)
   {
@@ -278,51 +399,34 @@ namespace MueLuTests {
     out << "version: " << MueLu::Version() << std::endl;
 
     RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::Build1DPoisson(36);
-    RCP<const Map> rowmap = A->getRowMap();
     RCP<AmalgamationInfo_kokkos> amalgInfo;
-    RCP<Aggregates_kokkos> aggregates = gimmeUncoupledAggregates(A, amalgInfo,true,false,false,false);
-    GO numAggs = aggregates->GetNumAggregates();
-    RCP<const Teuchos::Comm<int> > comm = TestHelpers_kokkos::Parameters::getDefaultComm();
 
-    TEST_EQUALITY(aggregates->AggregatesCrossProcessors(),false);
+    RCP<Aggregates_kokkos> aggregates;
+    RCP<LWGraph_kokkos> graph;
+    gimmeUncoupledAggregates_kokkos(A, graph, aggregates, true, false, false, false);
+    const GO numAggs = aggregates->GetNumAggregates();
 
-    auto aggSizes = aggregates->ComputeAggregateSizes(true);
-
-    bool foundAggNotSize3=false;
-    for (int i=0; i < as<int>(aggSizes.size()); ++i)
-      if (aggSizes[i] != 3) {
-        foundAggNotSize3=true;
-        break;
-      }
-
-    switch (comm->getSize()) {
-
-      case 1 :
-        TEST_EQUALITY(numAggs, 12);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      case 2:
-        TEST_EQUALITY(numAggs, 6);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      case 3:
-        TEST_EQUALITY(numAggs, 4);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      case 4:
-        TEST_EQUALITY(numAggs, 3);
-        TEST_EQUALITY(foundAggNotSize3, false);
-        break;
-
-      default:
-        std::string msg = "Only 1-4 MPI processes are supported.";
-        //throw(MueLu::Exceptions::NotImplemented(msg));
-        out << msg << std::endl;
-        break;
-    }
+    TEST_INEQUALITY(numAggs, 0);
+    TEST_EQUALITY(aggregates->AggregatesCrossProcessors(), false);
+
+    typename Aggregates_kokkos::aggregates_sizes_type::const_type aggSizes
+      = aggregates->ComputeAggregateSizes(true);
+    typename Aggregates_kokkos::aggregates_sizes_type::const_type::HostMirror aggSizes_h =
+      Kokkos::create_mirror_view(aggSizes);
+    Kokkos::deep_copy(aggSizes_h, aggSizes);
+
+    LO numBadAggregates = 0;
+    Kokkos::parallel_reduce("Checking aggregates sizes",
+                            Kokkos::RangePolicy<LO, typename Aggregates_kokkos::execution_space>(0, aggSizes_h.extent(0)),
+                            KOKKOS_LAMBDA(const LO aggIdx, LO& lNumBadAggregates) {
+                              if ((aggSizes_h(aggIdx) < 1) || (3 < aggSizes_h(aggIdx))) {
+                                lNumBadAggregates += 1;
+                              }
+                            }, numBadAggregates);
+    TEST_EQUALITY(numBadAggregates, 0);
+
+    const LO numDiscontiguous = checkAggregatesContiguous(*graph, *aggregates);
+    TEST_EQUALITY(numDiscontiguous, 0);
   } //UncoupledPhase1
 
   TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Aggregates_kokkos, UncoupledPhase2, Scalar, LocalOrdinal, GlobalOrdinal, Node)
@@ -333,12 +437,17 @@ namespace MueLuTests {
     out << "version: " << MueLu::Version() << std::endl;
 
     RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::Build1DPoisson(36);
-    RCP<const Map> rowmap = A->getRowMap();
-    RCP<AmalgamationInfo_kokkos> amalgInfo;
-    bool bSuccess = true;
-    TEUCHOS_TEST_THROW(gimmeUncoupledAggregates(A, amalgInfo,false,true,true,false),
-      MueLu::Exceptions::RuntimeError, out, bSuccess);
-    TEST_EQUALITY(bSuccess, true);
+
+    RCP<LWGraph_kokkos> graph;
+    RCP<Aggregates_kokkos> aggregates;
+    gimmeUncoupledAggregates_kokkos(A, graph, aggregates, false, true, true, false);
+    GO numAggs = aggregates->GetNumAggregates();
+
+    TEST_INEQUALITY(numAggs, 0);
+    TEST_EQUALITY(aggregates->AggregatesCrossProcessors(),false);
+
+    const LO numDiscontiguous = checkAggregatesContiguous(*graph, *aggregates);
+    TEST_EQUALITY(numDiscontiguous, 0);
   } //UncoupledPhase2
 
   TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Aggregates_kokkos, UncoupledPhase3, Scalar, LocalOrdinal, GlobalOrdinal, Node)
@@ -349,14 +458,29 @@ namespace MueLuTests {
     out << "version: " << MueLu::Version() << std::endl;
 
     RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::Build1DPoisson(36);
-    RCP<const Map> rowmap = A->getRowMap();
     RCP<AmalgamationInfo_kokkos> amalgInfo;
-    RCP<Aggregates_kokkos> aggregates = gimmeUncoupledAggregates(A, amalgInfo,false,false,false,true);
+
+    RCP<Aggregates_kokkos> aggregates = gimmeUncoupledAggregates_kokkos(A, false, false, false, true);
     GO numAggs = aggregates->GetNumAggregates();
-    RCP<const Teuchos::Comm<int> > comm = TestHelpers_kokkos::Parameters::getDefaultComm();
 
-    TEST_EQUALITY(aggregates->AggregatesCrossProcessors(),false);
     TEST_INEQUALITY(numAggs, 0);
+    TEST_EQUALITY(aggregates->AggregatesCrossProcessors(),false);
+
+    typename Aggregates_kokkos::aggregates_sizes_type::const_type aggSizes
+      = aggregates->ComputeAggregateSizes(true);
+    typename Aggregates_kokkos::aggregates_sizes_type::const_type::HostMirror aggSizes_h =
+      Kokkos::create_mirror_view(aggSizes);
+    Kokkos::deep_copy(aggSizes_h, aggSizes);
+
+    LO numBadAggregates = 0;
+    Kokkos::parallel_reduce("Checking aggregates sizes",
+                            Kokkos::RangePolicy<LO, typename Aggregates_kokkos::execution_space>(0, aggSizes_h.extent(0)),
+                            KOKKOS_LAMBDA(const LO aggIdx, LO& lNumBadAggregates) {
+                              if ((aggSizes_h(aggIdx) < 1) || (5 < aggSizes_h(aggIdx))) {
+                                lNumBadAggregates += 1;
+                              }
+                            }, numBadAggregates);
+    TEST_EQUALITY(numBadAggregates, 0);
 
   } //UncoupledPhase3
 
@@ -364,7 +488,7 @@ namespace MueLuTests {
   TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, JustUncoupledAggregation, SC, LO, GO, NO) \
   TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, JustDist2UncoupledAggregation, SC, LO, GO, NO) \
   TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, JustDist2DeterUncoupledAggregation, SC, LO, GO, NO) \
-  TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, GetNumUncoupledAggregates, SC, LO, GO, NO) \
+  TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, DiscontiguousAggregates, SC, LO, GO, NO) \
   TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, UncoupledPhase1, SC, LO, GO, NO) \
   TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, UncoupledPhase2, SC, LO, GO, NO) \
   TEUCHOS_UNIT_TEST_TEMPLATE_4_INSTANT(Aggregates_kokkos, UncoupledPhase3, SC, LO, GO, NO)

From e3fcdc9a8d51713ef12a624eccd874150c14a98a Mon Sep 17 00:00:00 2001
From: Luc Berger-Vergiat <lberge@sandia.gov>
Date: Wed, 20 Nov 2019 13:53:12 -0700
Subject: [PATCH 14/21] MueLu: gold file rebase and change of logic for issue
 #6269

This commits modifies ParameterListInterpeter to ignore non-deterministic output
 from the refactored uncoupled aggregation.
---
 .../interface/ParameterListInterpreter.cpp    | 34 ++++++++++++++
 .../Output/MLcoarse1_tpetra.gold              | 20 ++++-----
 .../Output/MLcoarse2_tpetra.gold              | 40 ++++++++---------
 .../Output/MLcoarse3_tpetra.gold              | 30 ++++++-------
 .../Output/MLcoarse5_tpetra.gold              | 12 ++---
 .../Output/MLpgamg1_tpetra.gold               | 30 ++++++-------
 .../Output/MLsmoother1_tpetra.gold            | 32 +++++++-------
 .../Output/MLsmoother2_tpetra.gold            | 32 +++++++-------
 .../Output/MLsmoother3_tpetra.gold            | 30 ++++++-------
 .../Output/MLsmoother4_tpetra.gold            | 30 ++++++-------
 .../Output/MLunsmoothed1_tpetra.gold          | 32 +++++++-------
 .../Output/aggregation1_tpetra.gold           | 12 ++---
 .../Output/aggregation3_tpetra.gold           | 12 ++---
 .../Output/aggregation4_tpetra.gold           | 12 ++---
 .../kokkos-complex/Output/coarse1_tpetra.gold | 20 ++++-----
 .../kokkos-complex/Output/coarse2_tpetra.gold | 40 ++++++++---------
 .../kokkos-complex/Output/coarse3_tpetra.gold | 12 ++---
 .../Output/default_e3d_tpetra.gold            | 12 ++---
 .../Output/default_mhd_np4_tpetra.gold        | 12 ++---
 .../Output/default_mhd_tpetra.gold            | 12 ++---
 .../Output/default_p2d_tpetra.gold            | 12 ++---
 .../Output/default_p3d_tpetra.gold            | 12 ++---
 .../Output/default_pg_np4_tpetra.gold         | 14 +++---
 .../Output/default_pg_tpetra.gold             | 12 ++---
 .../Output/driver_drekar1_np4_tpetra.gold     | 12 ++---
 .../Output/driver_drekar1_tpetra.gold         | 20 ++++-----
 .../Output/driver_drekar2_np4_tpetra.gold     | 12 ++---
 .../Output/driver_drekar2_tpetra.gold         | 20 ++++-----
 .../kokkos-complex/Output/emin1_tpetra.gold   | 12 ++---
 .../kokkos-complex/Output/emin2_tpetra.gold   | 12 ++---
 .../kokkos-complex/Output/emin3_tpetra.gold   | 12 ++---
 .../kokkos-complex/Output/empty_tpetra.gold   | 12 ++---
 .../Output/operator_solve_1_np1_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_1_np4_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_5_np1_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_5_np4_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_6_np1_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_6_np4_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_7_np1_tpetra.gold   |  6 +--
 .../Output/operator_solve_7_np4_tpetra.gold   |  6 +--
 .../kokkos-complex/Output/pg1_tpetra.gold     | 12 ++---
 .../kokkos-complex/Output/pg2_tpetra.gold     | 12 ++---
 .../Output/repartition1_np4_tpetra.gold       | 14 +++---
 .../Output/repartition1_tpetra.gold           | 12 ++---
 .../Output/repartition3_np4_tpetra.gold       | 14 +++---
 .../Output/repartition3_tpetra.gold           | 12 ++---
 .../Output/repartition4_np4_tpetra.gold       | 14 +++---
 .../Output/repartition4_tpetra.gold           | 12 ++---
 .../Output/reuse-RAP-1_np4_tpetra.gold        | 16 +++----
 .../Output/reuse-RAP-1_tpetra.gold            | 12 ++---
 .../Output/reuse-RAP-2_np4_tpetra.gold        | 16 +++----
 .../Output/reuse-RAP-2_tpetra.gold            | 12 ++---
 .../Output/reuse-RP-2_np4_tpetra.gold         | 16 +++----
 .../Output/reuse-RP-2_tpetra.gold             | 12 ++---
 .../Output/reuse-S-1_np4_tpetra.gold          | 28 ++++++------
 .../Output/reuse-S-1_tpetra.gold              | 24 +++++-----
 .../Output/reuse-full-1_np4_tpetra.gold       | 16 +++----
 .../Output/reuse-full-1_tpetra.gold           | 12 ++---
 .../Output/reuse-none_np4_tpetra.gold         | 28 ++++++------
 .../Output/reuse-none_tpetra.gold             | 24 +++++-----
 .../Output/reuse-tP-1_np4_tpetra.gold         | 16 +++----
 .../Output/reuse-tP-1_tpetra.gold             | 12 ++---
 .../Output/reuse-tP-2_np4_tpetra.gold         | 22 +++++-----
 .../Output/reuse-tP-2_tpetra.gold             | 18 ++++----
 .../Output/reuse-tP-3_np4_tpetra.gold         | 22 +++++-----
 .../Output/reuse-tP-3_tpetra.gold             | 18 ++++----
 .../Output/smoother10_tpetra.gold             | 12 ++---
 .../Output/smoother11_tpetra.gold             | 12 ++---
 .../Output/smoother12_tpetra.gold             | 40 ++++++++---------
 .../Output/smoother13_tpetra.gold             | 12 ++---
 .../Output/smoother1_tpetra.gold              | 12 ++---
 .../Output/smoother2_tpetra.gold              | 12 ++---
 .../Output/smoother3_tpetra.gold              | 12 ++---
 .../Output/smoother4_tpetra.gold              | 12 ++---
 .../Output/smoother5_tpetra.gold              | 12 ++---
 .../Output/smoother6_tpetra.gold              | 12 ++---
 .../Output/smoother9_tpetra.gold              | 12 ++---
 .../kokkos-complex/Output/sync1_tpetra.gold   | 12 ++---
 .../Output/transpose1_tpetra.gold             | 12 ++---
 .../Output/transpose2_np4_tpetra.gold         | 14 +++---
 .../Output/transpose2_tpetra.gold             | 12 ++---
 .../Output/transpose3_np4_tpetra.gold         | 14 +++---
 .../Output/transpose3_tpetra.gold             | 12 ++---
 .../Output/unsmoothed1_tpetra.gold            | 12 ++---
 .../interface/kokkos/Output/MLaux_tpetra.gold |  6 +--
 .../kokkos/Output/MLcoarse1_tpetra.gold       | 20 ++++-----
 .../kokkos/Output/MLcoarse2_tpetra.gold       | 40 ++++++++---------
 .../kokkos/Output/MLcoarse3_tpetra.gold       | 30 ++++++-------
 .../kokkos/Output/MLcoarse4_tpetra.gold       | 32 +++++++-------
 .../kokkos/Output/MLcoarse5_tpetra.gold       | 12 ++---
 .../kokkos/Output/MLpgamg1_tpetra.gold        | 32 +++++++-------
 .../Output/MLrepartitioning1_tpetra.gold      | 40 ++++++++---------
 .../Output/MLrepartitioning2_tpetra.gold      | 30 ++++++-------
 .../Output/MLrepartitioning3_tpetra.gold      | 30 ++++++-------
 .../kokkos/Output/MLsmoother1_tpetra.gold     | 30 ++++++-------
 .../kokkos/Output/MLsmoother2_tpetra.gold     | 32 +++++++-------
 .../kokkos/Output/MLsmoother3_tpetra.gold     | 30 ++++++-------
 .../kokkos/Output/MLsmoother4_tpetra.gold     | 30 ++++++-------
 .../kokkos/Output/MLunsmoothed1_tpetra.gold   | 32 +++++++-------
 .../kokkos/Output/aggregation1_tpetra.gold    | 12 ++---
 .../kokkos/Output/aggregation3_tpetra.gold    | 12 ++---
 .../kokkos/Output/aggregation4_tpetra.gold    | 12 ++---
 .../kokkos/Output/coarse1_tpetra.gold         | 20 ++++-----
 .../kokkos/Output/coarse2_tpetra.gold         | 40 ++++++++---------
 .../kokkos/Output/coarse3_tpetra.gold         | 12 ++---
 .../kokkos/Output/default_e3d_tpetra.gold     | 12 ++---
 .../kokkos/Output/default_mhd_np4_tpetra.gold | 12 ++---
 .../kokkos/Output/default_mhd_tpetra.gold     | 12 ++---
 .../kokkos/Output/default_p2d_tpetra.gold     | 12 ++---
 .../kokkos/Output/default_p3d_tpetra.gold     | 12 ++---
 .../kokkos/Output/default_pg_np4_tpetra.gold  | 14 +++---
 .../kokkos/Output/default_pg_tpetra.gold      | 12 ++---
 .../Output/driver_drekar1_np4_tpetra.gold     | 12 ++---
 .../kokkos/Output/driver_drekar1_tpetra.gold  | 20 ++++-----
 .../Output/driver_drekar2_np4_tpetra.gold     | 12 ++---
 .../kokkos/Output/driver_drekar2_tpetra.gold  | 20 ++++-----
 .../interface/kokkos/Output/emin1_tpetra.gold | 12 ++---
 .../interface/kokkos/Output/emin2_tpetra.gold | 12 ++---
 .../interface/kokkos/Output/emin3_tpetra.gold | 12 ++---
 .../interface/kokkos/Output/empty_tpetra.gold | 12 ++---
 .../Output/operator_solve_1_np1_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_1_np4_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_5_np1_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_5_np4_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_6_np1_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_6_np4_tpetra.gold   | 18 ++++----
 .../Output/operator_solve_7_np1_tpetra.gold   |  6 +--
 .../Output/operator_solve_7_np4_tpetra.gold   |  6 +--
 .../interface/kokkos/Output/pg1_tpetra.gold   | 12 ++---
 .../interface/kokkos/Output/pg2_tpetra.gold   | 12 ++---
 .../Output/repartition1_np4_tpetra.gold       | 14 +++---
 .../kokkos/Output/repartition1_tpetra.gold    | 12 ++---
 .../Output/repartition3_np4_tpetra.gold       | 14 +++---
 .../kokkos/Output/repartition3_tpetra.gold    | 12 ++---
 .../Output/repartition4_np4_tpetra.gold       | 14 +++---
 .../kokkos/Output/repartition4_tpetra.gold    | 12 ++---
 .../kokkos/Output/reuse-RAP-1_np4_tpetra.gold | 16 +++----
 .../kokkos/Output/reuse-RAP-1_tpetra.gold     | 12 ++---
 .../kokkos/Output/reuse-RAP-2_np4_tpetra.gold | 16 +++----
 .../kokkos/Output/reuse-RAP-2_tpetra.gold     | 12 ++---
 .../kokkos/Output/reuse-RP-2_np4_tpetra.gold  | 16 +++----
 .../kokkos/Output/reuse-RP-2_tpetra.gold      | 12 ++---
 .../kokkos/Output/reuse-S-1_np4_tpetra.gold   | 28 ++++++------
 .../kokkos/Output/reuse-S-1_tpetra.gold       | 24 +++++-----
 .../Output/reuse-full-1_np4_tpetra.gold       | 16 +++----
 .../kokkos/Output/reuse-full-1_tpetra.gold    | 12 ++---
 .../kokkos/Output/reuse-none_np4_tpetra.gold  | 28 ++++++------
 .../kokkos/Output/reuse-none_tpetra.gold      | 24 +++++-----
 .../kokkos/Output/reuse-tP-1_np4_tpetra.gold  | 16 +++----
 .../kokkos/Output/reuse-tP-1_tpetra.gold      | 12 ++---
 .../kokkos/Output/reuse-tP-2_np4_tpetra.gold  | 22 +++++-----
 .../kokkos/Output/reuse-tP-2_tpetra.gold      | 18 ++++----
 .../kokkos/Output/reuse-tP-3_np4_tpetra.gold  | 22 +++++-----
 .../kokkos/Output/reuse-tP-3_tpetra.gold      | 18 ++++----
 .../kokkos/Output/smoother10_tpetra.gold      | 12 ++---
 .../kokkos/Output/smoother11_tpetra.gold      | 12 ++---
 .../kokkos/Output/smoother12_tpetra.gold      | 44 +++++++++----------
 .../kokkos/Output/smoother13_tpetra.gold      | 12 ++---
 .../kokkos/Output/smoother1_tpetra.gold       | 12 ++---
 .../kokkos/Output/smoother2_tpetra.gold       | 12 ++---
 .../kokkos/Output/smoother3_tpetra.gold       | 12 ++---
 .../kokkos/Output/smoother4_tpetra.gold       | 12 ++---
 .../kokkos/Output/smoother5_tpetra.gold       | 12 ++---
 .../kokkos/Output/smoother6_tpetra.gold       | 12 ++---
 .../kokkos/Output/smoother9_tpetra.gold       | 12 ++---
 .../interface/kokkos/Output/sync1_tpetra.gold | 12 ++---
 .../kokkos/Output/transpose1_tpetra.gold      | 12 ++---
 .../kokkos/Output/transpose2_np4_tpetra.gold  | 14 +++---
 .../kokkos/Output/transpose2_tpetra.gold      | 12 ++---
 .../kokkos/Output/transpose3_np4_tpetra.gold  | 14 +++---
 .../kokkos/Output/transpose3_tpetra.gold      | 12 ++---
 .../kokkos/Output/unsmoothed1_tpetra.gold     | 12 ++---
 .../kokkos/Output/unsmoothed2_tpetra.gold     | 12 ++---
 173 files changed, 1499 insertions(+), 1465 deletions(-)

diff --git a/packages/muelu/test/interface/ParameterListInterpreter.cpp b/packages/muelu/test/interface/ParameterListInterpreter.cpp
index bef2a65a91c9..e7ad61ba3ed8 100644
--- a/packages/muelu/test/interface/ParameterListInterpreter.cpp
+++ b/packages/muelu/test/interface/ParameterListInterpreter.cpp
@@ -375,6 +375,40 @@ int main_(Teuchos::CommandLineProcessor &clp, Xpetra::UnderlyingLib& lib, int ar
         run_sed("'/RCP/ s/=0x0/=0/g'", baseFile);
 #endif
 
+        // When using the kokkos refactor path, aggregation is non-deterministic
+        // This means that we need to remove most mentions of matrix sizes in the
+        // level smoothers and we also need to remove data from the summary
+        if(useKokkos) {
+          // Defining a couple helpful regex strings
+          const std::string floatRegex   = "[0-9]\\{1,\\}.[0-9]\\{1,\\}";
+          const std::string integerRegex = "[0-9]\\{1,\\}";
+
+          // Catch lines of the MueLu summary (except the first one which is a bit different)
+          std::string stringToReplace = integerRegex + "\\s*"
+            + integerRegex + "\\s*"
+            + integerRegex + "\\s*"
+            + floatRegex + "\\s*"
+            + floatRegex + "\\s*[0-9]";
+          std::string replacementString = "<ignored>";
+          run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
+
+          // Catch the first line of the MueLu summary
+          stringToReplace = integerRegex + "\\s*" + integerRegex + "\\s*"
+            + integerRegex + "\\s*" + floatRegex + "\\s*[0-9]";
+          run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
+
+          // Catch the matrix size related informations from Ifpack's output
+          stringToReplace = "Global matrix dimensions: [" + integerRegex + ",\\s*" + integerRegex
+            + "], Global nnz: " + integerRegex;
+          replacementString = "Global matrix dimensions: <ignored>, Global nnz: <ignored>";
+          run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
+
+          // Catch smoother complexity output from MueLu
+          stringToReplace = "Smoother complexity = " + floatRegex;
+          replacementString = "Smoother complexity = <ignored>";
+          run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
+        }
+
         // Run comparison (ignoring whitespaces)
         cmd = "diff -u -w -I\"^\\s*$\" " + baseFile + ".gold_filtered " + baseFile + ".out_filtered";
         int ret = system(cmd.c_str());
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse1_tpetra.gold
index c037455726e4..d9e99b51ee9c 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse1_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -284,7 +284,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  369   1105   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse2_tpetra.gold
index 115137ddb8b5..532c1d481476 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse2_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -387,7 +387,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -395,9 +395,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -460,9 +460,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  370   1108   2.99     3.00         1  
+  4  122   364    2.98     3.03         1  
+  5  33    97     2.94     3.70         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -470,9 +470,9 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
-Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [122, 122], Global nnz: 364}
 
 Smoother (level 5) pre  : <Direct> solver interface
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse3_tpetra.gold
index 6af61d306953..a42e8c373282 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse3_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -372,8 +372,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -381,7 +381,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse5_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse5_tpetra.gold
index c1c745091a80..ac064077e172 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse5_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLcoarse5_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLpgamg1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLpgamg1_tpetra.gold
index 74651a07c9c5..f229003b692b 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLpgamg1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLpgamg1_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -125,7 +125,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -133,9 +133,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -215,7 +215,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -223,9 +223,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -305,7 +305,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -313,9 +313,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -380,8 +380,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -389,7 +389,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother1_tpetra.gold
index 6af61d306953..ad4ace334ffd 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother1_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -365,15 +365,15 @@ smoother ->
 --------------------------------------------------------------------------------
 Number of levels    = 5
 Operator complexity = 1.49
-Smoother complexity = 1.98
+Smoother complexity = 1.97
 Cycle type          = V
 
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  121   361    2.98     3.05         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -381,7 +381,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother2_tpetra.gold
index 41e987ce5462..88b3f755e15e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother2_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -365,15 +365,15 @@ smoother ->
 --------------------------------------------------------------------------------
 Number of levels    = 5
 Operator complexity = 1.49
-Smoother complexity = 1.98
+Smoother complexity = 1.97
 Cycle type          = V
 
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  122   364    2.98     3.02         1  
 
 Smoother (level 0) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 Smoother (level 0) post : no smoother
@@ -384,7 +384,7 @@ Smoother (level 1) post : no smoother
 Smoother (level 2) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 Smoother (level 2) post : no smoother
 
-Smoother (level 3) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 Smoother (level 3) post : no smoother
 
 Smoother (level 4) pre  : <Direct> solver interface
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother3_tpetra.gold
index 00313beff161..fb97d83f0653 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother3_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -372,8 +372,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  122   364    2.98     3.03         1  
 
 Smoother (level 0) pre  : no smoother
 Smoother (level 0) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
@@ -385,7 +385,7 @@ Smoother (level 2) pre  : no smoother
 Smoother (level 2) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
 Smoother (level 3) pre  : no smoother
-Smoother (level 3) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother4_tpetra.gold
index 6af61d306953..a42e8c373282 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLsmoother4_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -372,8 +372,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -381,7 +381,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/MLunsmoothed1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/MLunsmoothed1_tpetra.gold
index a45d21752139..4ab174f68039 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/MLunsmoothed1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/MLunsmoothed1_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -115,7 +115,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -123,9 +123,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -196,7 +196,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -204,9 +204,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -277,7 +277,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -285,9 +285,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -337,15 +337,15 @@ smoother ->
 --------------------------------------------------------------------------------
 Number of levels    = 5
 Operator complexity = 1.49
-Smoother complexity = 1.98
+Smoother complexity = 1.97
 Cycle type          = V
 
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  121   361    2.98     3.05         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -353,7 +353,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/aggregation1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/aggregation1_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/aggregation1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/aggregation1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/aggregation3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/aggregation3_tpetra.gold
index e7d7e3ae372d..643b9c534dd0 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/aggregation3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/aggregation3_tpetra.gold
@@ -38,7 +38,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/aggregation4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/aggregation4_tpetra.gold
index e0e4d75e7ce9..8be7515ab73f 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/aggregation4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/aggregation4_tpetra.gold
@@ -38,7 +38,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -133,7 +133,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -141,9 +141,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/coarse1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/coarse1_tpetra.gold
index a66e27859835..80f9937f9bdc 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/coarse1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/coarse1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -284,7 +284,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  369   1105   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/coarse2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/coarse2_tpetra.gold
index 9874e5ed86ca..f688b772016f 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/coarse2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/coarse2_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -298,7 +298,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -306,9 +306,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -385,7 +385,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -393,9 +393,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -449,9 +449,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
+  5  37    109    2.95     3.27         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -459,9 +459,9 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
-Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [121, 121], Global nnz: 361}
 
 Smoother (level 5) pre  : no smoother
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/coarse3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/coarse3_tpetra.gold
index 71d82f923dfb..8bb840d62544 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/coarse3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/coarse3_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_e3d_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_e3d_tpetra.gold
index 2d92b652f75c..d93cb33e94d2 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_e3d_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_e3d_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_np4_tpetra.gold
index 015229a16a45..f6bc2eeb39a8 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_np4_tpetra.gold
@@ -32,7 +32,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -40,9 +40,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -104,7 +104,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -112,9 +112,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_tpetra.gold
index f8cdc51106ae..dd08ab2108a2 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_mhd_tpetra.gold
@@ -32,7 +32,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -40,9 +40,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -104,7 +104,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -112,9 +112,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_p2d_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_p2d_tpetra.gold
index 6204b99f1ac3..28bb77f5c0b2 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_p2d_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_p2d_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_p3d_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_p3d_tpetra.gold
index 6204b99f1ac3..28bb77f5c0b2 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_p3d_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_p3d_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_pg_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_pg_np4_tpetra.gold
index 554fbb625147..86c74183bb14 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_pg_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_pg_np4_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -200,7 +200,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         4  
+  2  1112  3346   3.01     3.00         4  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/default_pg_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/default_pg_tpetra.gold
index ea26983d8065..e10002f9f1bd 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/default_pg_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/default_pg_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_np4_tpetra.gold
index 3326b8d06e1e..609b1ee9b258 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -149,14 +149,14 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         1  
-  2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  2  1109  3325   3.00     3.01         1  
+  3  368   1102   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
 Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [3335, 3335], Global nnz: 10015}
 
-Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
+Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1109, 1109], Global nnz: 3325}
 
 Smoother (level 3) pre  : <Direct> solver interface
 Smoother (level 3) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_tpetra.gold
index df6bae674df6..6ec29339920c 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -312,7 +312,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -320,9 +320,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -431,7 +431,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  370   1108   2.99     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_np4_tpetra.gold
index 1b53e893a2b1..b7b77b5bc4d8 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_np4_tpetra.gold
@@ -41,7 +41,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -150,14 +150,14 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         1  
-  2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  2  1109  3325   3.00     3.01         1  
+  3  368   1102   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
 Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [3335, 3335], Global nnz: 10015}
 
-Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
+Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1109, 1109], Global nnz: 3325}
 
 Smoother (level 3) pre  : <Direct> solver interface
 Smoother (level 3) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_tpetra.gold
index 3473dfc0d8e2..5e4bba16bb4b 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/driver_drekar2_tpetra.gold
@@ -41,7 +41,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -178,7 +178,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -186,9 +186,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -315,7 +315,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -323,9 +323,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -434,7 +434,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  370   1108   2.99     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/emin1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/emin1_tpetra.gold
index 7ecbe43e9d94..048d3d5192db 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/emin1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/emin1_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -134,7 +134,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -142,9 +142,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/emin2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/emin2_tpetra.gold
index f6a2f53cbe57..76655260782f 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/emin2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/emin2_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -134,7 +134,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -142,9 +142,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/emin3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/emin3_tpetra.gold
index f25ed9c5a259..82f8b780e027 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/emin3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/emin3_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -134,7 +134,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -142,9 +142,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/empty_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/empty_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/empty_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/empty_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np1_tpetra.gold
index 20f68cb9c4eb..ead294f87e9b 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np4_tpetra.gold
index 06f7330fcd96..2d6b350c8fc0 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_1_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np1_tpetra.gold
index d9a648f67204..934d6cd4ae65 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np4_tpetra.gold
index 5afd6852a376..b638f7c8bec2 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_5_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np1_tpetra.gold
index f19941336bb3..4da27c45ddc9 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np4_tpetra.gold
index 3c8a3358fe1c..4ffd5cdc913b 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_6_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np1_tpetra.gold
index b6f08d3f32da..d44340395aa0 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np4_tpetra.gold
index 29d186b523cc..467a4d8d697e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/operator_solve_7_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/pg1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/pg1_tpetra.gold
index 7c5e0f92e821..4d828d342bfa 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/pg1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/pg1_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/pg2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/pg2_tpetra.gold
index 7c5e0f92e821..4d828d342bfa 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/pg2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/pg2_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/repartition1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/repartition1_np4_tpetra.gold
index a6f249e8fb18..c47d32e1bddb 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/repartition1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/repartition1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/repartition1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/repartition1_tpetra.gold
index 6e69d83b769f..17cfd1bcbafe 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/repartition1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/repartition1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/repartition3_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/repartition3_np4_tpetra.gold
index 9b8a8497cdf3..90a86a6d6a7e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/repartition3_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/repartition3_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -295,7 +295,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/repartition3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/repartition3_tpetra.gold
index 29a82dfd1e4b..45c1862fe800 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/repartition3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/repartition3_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/repartition4_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/repartition4_np4_tpetra.gold
index 3609331a0a65..b721c2cdfc2e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/repartition4_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/repartition4_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -294,7 +294,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         4  
+  2  1112  3346   3.01     3.00         4  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/repartition4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/repartition4_tpetra.gold
index 4e2a3e5f2eeb..cf5b1cca0c4f 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/repartition4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/repartition4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_np4_tpetra.gold
index c222dc6194a4..11c2d72caa87 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -283,7 +283,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -327,7 +327,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_tpetra.gold
index b00b61c957da..12248d63ccf7 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_np4_tpetra.gold
index 2b055cebc0f7..f6b78985e5f9 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -301,7 +301,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_tpetra.gold
index 72a7e51744c1..6e533dde78b1 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RAP-2_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_np4_tpetra.gold
index 7415d2ff7c60..f5028d31e11b 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -387,7 +387,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_tpetra.gold
index 7edab5dd70ea..316c9364a9f4 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-RP-2_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_np4_tpetra.gold
index 8c94cc12bfcd..43f77b391179 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -283,7 +283,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -334,7 +334,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -342,9 +342,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -470,7 +470,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -478,9 +478,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -577,7 +577,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_tpetra.gold
index 2204622fbc8a..3f311ecc547f 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-S-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -345,7 +345,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -353,9 +353,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -481,7 +481,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -489,9 +489,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_np4_tpetra.gold
index 241fab28d4d9..a38c7562e850 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -283,7 +283,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -308,7 +308,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_tpetra.gold
index f8240f7d2b36..181c0b497fdb 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-full-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_np4_tpetra.gold
index 82c8b23e9dde..df103205fe27 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -336,7 +336,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -344,9 +344,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -472,7 +472,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -480,9 +480,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -581,7 +581,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_tpetra.gold
index 45b6800b8499..1a1e294c5d26 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-none_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -345,7 +345,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -353,9 +353,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -481,7 +481,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -489,9 +489,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_np4_tpetra.gold
index 6710e7b44baf..ae89b3aba95e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -483,7 +483,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_tpetra.gold
index b6463572088e..d46263a1986e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_np4_tpetra.gold
index c1217b433a5d..91af4fb9044e 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_np4_tpetra.gold
@@ -41,7 +41,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -178,7 +178,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -186,9 +186,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -287,7 +287,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -425,7 +425,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -433,9 +433,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -534,7 +534,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_tpetra.gold
index d0a200744e69..948089d7e0c4 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-2_tpetra.gold
@@ -41,7 +41,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -178,7 +178,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -186,9 +186,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -434,7 +434,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -442,9 +442,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_np4_tpetra.gold
index 8fd9b7d222a3..76078f5ddeec 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -423,7 +423,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -431,9 +431,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -532,7 +532,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_tpetra.gold
index 6998c0daaec1..01c4db11e1dc 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/reuse-tP-3_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -432,7 +432,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -440,9 +440,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother10_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother10_tpetra.gold
index 7ecaf32b845e..358824b63971 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother10_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother10_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother11_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother11_tpetra.gold
index 4a348d927e22..214f41489c2a 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother11_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother11_tpetra.gold
@@ -56,7 +56,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -64,9 +64,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother12_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother12_tpetra.gold
index c4bf69926823..a040f223d695 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother12_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother12_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -298,7 +298,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -306,9 +306,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -385,7 +385,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -393,9 +393,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -458,9 +458,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  369   1105   2.99     3.01         1  
+  4  120   358    2.98     3.08         1  
+  5  36    106    2.94     3.33         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -468,9 +468,9 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
-Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [120, 120], Global nnz: 358}
 
 Smoother (level 5) pre  : <Direct> solver interface
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother13_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother13_tpetra.gold
index 1f9fdb5f7635..4d0f95a31dea 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother13_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother13_tpetra.gold
@@ -44,7 +44,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -52,9 +52,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -138,7 +138,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -146,9 +146,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother1_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother2_tpetra.gold
index 51caf4695c24..a67cab4ffbd6 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother2_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother3_tpetra.gold
index dd796fbdabad..8f3a7b0636bd 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother3_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother4_tpetra.gold
index f5f426f6b623..4510989a7c73 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother4_tpetra.gold
@@ -18,7 +18,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -26,9 +26,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -86,7 +86,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -94,9 +94,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother5_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother5_tpetra.gold
index 6204b99f1ac3..28bb77f5c0b2 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother5_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother5_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother6_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother6_tpetra.gold
index 404a13da5738..ed140afb5165 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother6_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother6_tpetra.gold
@@ -25,7 +25,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -33,9 +33,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -100,7 +100,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -108,9 +108,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/smoother9_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/smoother9_tpetra.gold
index e10499df589a..b75c38a5ec7f 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/smoother9_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/smoother9_tpetra.gold
@@ -44,7 +44,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -52,9 +52,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -138,7 +138,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -146,9 +146,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/sync1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/sync1_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/sync1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/sync1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/transpose1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/transpose1_tpetra.gold
index 99b828f36504..3e957f860475 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/transpose1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/transpose1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -120,7 +120,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -128,9 +128,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/transpose2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/transpose2_np4_tpetra.gold
index 7842282871db..947ecd9d84a1 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/transpose2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/transpose2_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/transpose2_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/transpose2_tpetra.gold
index bc8b2deac930..5cc73d12dacb 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/transpose2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/transpose2_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/transpose3_np4_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/transpose3_np4_tpetra.gold
index 0ea82721bb82..9c7d93557886 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/transpose3_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/transpose3_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/transpose3_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/transpose3_tpetra.gold
index 7fb87ce3b349..2be8ce9b15b3 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/transpose3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/transpose3_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos-complex/Output/unsmoothed1_tpetra.gold b/packages/muelu/test/interface/kokkos-complex/Output/unsmoothed1_tpetra.gold
index 6f9ce8a6a4a8..3e504ae003a4 100644
--- a/packages/muelu/test/interface/kokkos-complex/Output/unsmoothed1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos-complex/Output/unsmoothed1_tpetra.gold
@@ -36,7 +36,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -44,9 +44,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -116,7 +116,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -124,9 +124,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/MLaux_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLaux_tpetra.gold
index 33d90f2c343b..4c1814c05d3b 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLaux_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLaux_tpetra.gold
@@ -42,7 +42,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -50,9 +50,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/MLcoarse1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLcoarse1_tpetra.gold
index c037455726e4..d9e99b51ee9c 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLcoarse1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLcoarse1_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -284,7 +284,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  369   1105   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/MLcoarse2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLcoarse2_tpetra.gold
index 115137ddb8b5..9ebb5aa87d8b 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLcoarse2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLcoarse2_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -387,7 +387,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -395,9 +395,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -460,9 +460,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
+  5  36    106    2.94     3.36         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -470,9 +470,9 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
-Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [121, 121], Global nnz: 361}
 
 Smoother (level 5) pre  : <Direct> solver interface
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLcoarse3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLcoarse3_tpetra.gold
index 6af61d306953..a42e8c373282 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLcoarse3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLcoarse3_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -372,8 +372,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -381,7 +381,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLcoarse4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLcoarse4_tpetra.gold
index e26d42462ca4..1a358aec2970 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLcoarse4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLcoarse4_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -383,8 +383,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  120   358    2.98     3.08         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -392,8 +392,8 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
-Smoother (level 4) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Gauss-Seidel, sweeps: 25, damping factor: 0.6, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Gauss-Seidel, sweeps: 25, damping factor: 0.6, Global matrix dimensions: [120, 120], Global nnz: 358}
 Smoother (level 4) post : no smoother
 
diff --git a/packages/muelu/test/interface/kokkos/Output/MLcoarse5_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLcoarse5_tpetra.gold
index c1c745091a80..ac064077e172 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLcoarse5_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLcoarse5_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/MLpgamg1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLpgamg1_tpetra.gold
index 74651a07c9c5..9f7ffaf456e5 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLpgamg1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLpgamg1_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -125,7 +125,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -133,9 +133,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -215,7 +215,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -223,9 +223,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -305,7 +305,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -313,9 +313,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -373,15 +373,15 @@ smoother ->
 --------------------------------------------------------------------------------
 Number of levels    = 5
 Operator complexity = 1.49
-Smoother complexity = 1.98
+Smoother complexity = 1.97
 Cycle type          = V
 
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  122   364    2.98     3.02         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -389,7 +389,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLrepartitioning1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLrepartitioning1_tpetra.gold
index c1fecf97bb22..fb269173061c 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLrepartitioning1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLrepartitioning1_tpetra.gold
@@ -41,7 +41,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -174,7 +174,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -182,9 +182,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -307,7 +307,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -315,9 +315,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -440,7 +440,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -448,9 +448,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -573,7 +573,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -581,9 +581,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -688,9 +688,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  369   1105   2.99     3.01         1  
+  4  121   361    2.98     3.05         1  
+  5  36    106    2.94     3.36         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -698,9 +698,9 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
-Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [121, 121], Global nnz: 361}
 
 Smoother (level 5) pre  : <Direct> solver interface
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLrepartitioning2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLrepartitioning2_tpetra.gold
index d7e80585d1e8..f15d24f35f25 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLrepartitioning2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLrepartitioning2_tpetra.gold
@@ -41,7 +41,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -174,7 +174,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -182,9 +182,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -307,7 +307,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -315,9 +315,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -440,7 +440,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -448,9 +448,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -554,8 +554,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  121   361    2.98     3.06         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -563,7 +563,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLrepartitioning3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLrepartitioning3_tpetra.gold
index 9488d95bd685..92a2015e069f 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLrepartitioning3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLrepartitioning3_tpetra.gold
@@ -41,7 +41,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -174,7 +174,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -182,9 +182,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -307,7 +307,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -315,9 +315,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -440,7 +440,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -448,9 +448,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -554,8 +554,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  122   364    2.98     3.03         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -563,7 +563,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLsmoother1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLsmoother1_tpetra.gold
index 6af61d306953..482b48594809 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLsmoother1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLsmoother1_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -372,8 +372,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  122   364    2.98     3.03         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -381,7 +381,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLsmoother2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLsmoother2_tpetra.gold
index 41e987ce5462..9cf2b7d3974c 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLsmoother2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLsmoother2_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -365,15 +365,15 @@ smoother ->
 --------------------------------------------------------------------------------
 Number of levels    = 5
 Operator complexity = 1.49
-Smoother complexity = 1.98
+Smoother complexity = 1.97
 Cycle type          = V
 
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  121   361    2.98     3.05         1  
 
 Smoother (level 0) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 Smoother (level 0) post : no smoother
@@ -384,7 +384,7 @@ Smoother (level 1) post : no smoother
 Smoother (level 2) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 Smoother (level 2) post : no smoother
 
-Smoother (level 3) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) pre  : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 Smoother (level 3) post : no smoother
 
 Smoother (level 4) pre  : <Direct> solver interface
diff --git a/packages/muelu/test/interface/kokkos/Output/MLsmoother3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLsmoother3_tpetra.gold
index 00313beff161..6fe698989d3f 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLsmoother3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLsmoother3_tpetra.gold
@@ -38,7 +38,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -123,7 +123,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -131,9 +131,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -299,7 +299,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -307,9 +307,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -372,8 +372,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  122   364    2.98     3.02         1  
 
 Smoother (level 0) pre  : no smoother
 Smoother (level 0) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
@@ -385,7 +385,7 @@ Smoother (level 2) pre  : no smoother
 Smoother (level 2) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
 Smoother (level 3) pre  : no smoother
-Smoother (level 3) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) post : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLsmoother4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLsmoother4_tpetra.gold
index 6a49d9c8c304..be63c5c14118 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLsmoother4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLsmoother4_tpetra.gold
@@ -32,7 +32,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -40,9 +40,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -111,7 +111,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -119,9 +119,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -193,7 +193,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -201,9 +201,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -275,7 +275,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -283,9 +283,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -348,8 +348,8 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  370   1108   2.99     3.00         1  
+  4  122   364    2.98     3.03         1  
 
 Smoother (level 0) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -357,7 +357,7 @@ Smoother (level 1) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: tr
 
 Smoother (level 2) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [370, 370], Global nnz: 1108}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/MLunsmoothed1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/MLunsmoothed1_tpetra.gold
index a45d21752139..6ae0d8bad28b 100644
--- a/packages/muelu/test/interface/kokkos/Output/MLunsmoothed1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/MLunsmoothed1_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -115,7 +115,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -123,9 +123,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -196,7 +196,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -204,9 +204,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -277,7 +277,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1   [default]
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -285,9 +285,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 1   [unused]
 aggregation: max selected neighbors = 0   [unused]
 aggregation: ordering = natural   [unused]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -337,15 +337,15 @@ smoother ->
 --------------------------------------------------------------------------------
 Number of levels    = 5
 Operator complexity = 1.49
-Smoother complexity = 1.98
+Smoother complexity = 1.97
 Cycle type          = V
 
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
+  3  369   1105   2.99     3.01         1  
+  4  120   358    2.98     3.08         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -353,7 +353,7 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 2, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
 Smoother (level 4) pre  : <Direct> solver interface
 Smoother (level 4) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/aggregation1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/aggregation1_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos/Output/aggregation1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/aggregation1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/aggregation3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/aggregation3_tpetra.gold
index e7d7e3ae372d..643b9c534dd0 100644
--- a/packages/muelu/test/interface/kokkos/Output/aggregation3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/aggregation3_tpetra.gold
@@ -38,7 +38,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/aggregation4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/aggregation4_tpetra.gold
index e0e4d75e7ce9..8be7515ab73f 100644
--- a/packages/muelu/test/interface/kokkos/Output/aggregation4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/aggregation4_tpetra.gold
@@ -38,7 +38,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -133,7 +133,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -141,9 +141,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/coarse1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/coarse1_tpetra.gold
index a66e27859835..80f9937f9bdc 100644
--- a/packages/muelu/test/interface/kokkos/Output/coarse1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/coarse1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -284,7 +284,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  369   1105   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/coarse2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/coarse2_tpetra.gold
index 9874e5ed86ca..31d5096120f3 100644
--- a/packages/muelu/test/interface/kokkos/Output/coarse2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/coarse2_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -298,7 +298,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -306,9 +306,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -385,7 +385,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -393,9 +393,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -449,9 +449,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  369   1105   2.99     3.01         1  
+  4  122   364    2.98     3.02         1  
+  5  34    100    2.94     3.59         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -459,9 +459,9 @@ Smoother (level 1) both : "Ifpack2::Relaxation": {Initialized: true, Computed: t
 
 Smoother (level 2) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
-Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [122, 122], Global nnz: 364}
 
 Smoother (level 5) pre  : no smoother
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/coarse3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/coarse3_tpetra.gold
index 71d82f923dfb..8bb840d62544 100644
--- a/packages/muelu/test/interface/kokkos/Output/coarse3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/coarse3_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/default_e3d_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_e3d_tpetra.gold
index da58a771b266..5ba32285575f 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_e3d_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_e3d_tpetra.gold
@@ -31,7 +31,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -39,9 +39,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -112,7 +112,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -120,9 +120,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/default_mhd_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_mhd_np4_tpetra.gold
index 015229a16a45..f6bc2eeb39a8 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_mhd_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_mhd_np4_tpetra.gold
@@ -32,7 +32,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -40,9 +40,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -104,7 +104,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -112,9 +112,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/default_mhd_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_mhd_tpetra.gold
index f8cdc51106ae..dd08ab2108a2 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_mhd_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_mhd_tpetra.gold
@@ -32,7 +32,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -40,9 +40,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -104,7 +104,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -112,9 +112,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/default_p2d_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_p2d_tpetra.gold
index bb5f7dbd8955..54243a9e8e6a 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_p2d_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_p2d_tpetra.gold
@@ -31,7 +31,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -39,9 +39,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -112,7 +112,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -120,9 +120,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/default_p3d_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_p3d_tpetra.gold
index bb5f7dbd8955..54243a9e8e6a 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_p3d_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_p3d_tpetra.gold
@@ -31,7 +31,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -39,9 +39,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -112,7 +112,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -120,9 +120,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/default_pg_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_pg_np4_tpetra.gold
index 554fbb625147..86c74183bb14 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_pg_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_pg_np4_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -200,7 +200,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         4  
+  2  1112  3346   3.01     3.00         4  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/default_pg_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/default_pg_tpetra.gold
index ea26983d8065..e10002f9f1bd 100644
--- a/packages/muelu/test/interface/kokkos/Output/default_pg_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/default_pg_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/driver_drekar1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/driver_drekar1_np4_tpetra.gold
index b5c80726b2b3..ec479f34e954 100644
--- a/packages/muelu/test/interface/kokkos/Output/driver_drekar1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/driver_drekar1_np4_tpetra.gold
@@ -35,7 +35,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -43,9 +43,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -144,14 +144,14 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         1  
-  2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  2  1109  3325   3.00     3.01         1  
+  3  368   1102   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
 Smoother (level 1) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [3335, 3335], Global nnz: 10015}
 
-Smoother (level 2) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
+Smoother (level 2) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [1109, 1109], Global nnz: 3325}
 
 Smoother (level 3) pre  : <Direct> solver interface
 Smoother (level 3) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/driver_drekar1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/driver_drekar1_tpetra.gold
index 7aed5fefa3ef..e79ebedf6e99 100644
--- a/packages/muelu/test/interface/kokkos/Output/driver_drekar1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/driver_drekar1_tpetra.gold
@@ -35,7 +35,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -43,9 +43,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -166,7 +166,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -174,9 +174,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -297,7 +297,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -305,9 +305,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -416,7 +416,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  370   1108   2.99     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/driver_drekar2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/driver_drekar2_np4_tpetra.gold
index 49d10118c2df..4b80fc5b195f 100644
--- a/packages/muelu/test/interface/kokkos/Output/driver_drekar2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/driver_drekar2_np4_tpetra.gold
@@ -36,7 +36,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -44,9 +44,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -145,14 +145,14 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         1  
-  2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  2  1109  3325   3.00     3.01         1  
+  3  369   1105   2.99     3.01         1  
 
 Smoother (level 0) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
 Smoother (level 1) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [3335, 3335], Global nnz: 10015}
 
-Smoother (level 2) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
+Smoother (level 2) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [1109, 1109], Global nnz: 3325}
 
 Smoother (level 3) pre  : <Direct> solver interface
 Smoother (level 3) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/driver_drekar2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/driver_drekar2_tpetra.gold
index c741a3ffa16d..19755b316756 100644
--- a/packages/muelu/test/interface/kokkos/Output/driver_drekar2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/driver_drekar2_tpetra.gold
@@ -36,7 +36,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -44,9 +44,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -168,7 +168,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -176,9 +176,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -300,7 +300,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -308,9 +308,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -419,7 +419,7 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
+  3  370   1108   2.99     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 2, lambdaMax = <ignored>, alpha: 20, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/emin1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/emin1_tpetra.gold
index 7ecbe43e9d94..048d3d5192db 100644
--- a/packages/muelu/test/interface/kokkos/Output/emin1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/emin1_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -134,7 +134,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -142,9 +142,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/emin2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/emin2_tpetra.gold
index f6a2f53cbe57..76655260782f 100644
--- a/packages/muelu/test/interface/kokkos/Output/emin2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/emin2_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -134,7 +134,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -142,9 +142,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/emin3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/emin3_tpetra.gold
index f25ed9c5a259..82f8b780e027 100644
--- a/packages/muelu/test/interface/kokkos/Output/emin3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/emin3_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -134,7 +134,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -142,9 +142,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/empty_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/empty_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos/Output/empty_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/empty_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np1_tpetra.gold
index 20f68cb9c4eb..ead294f87e9b 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np4_tpetra.gold
index 06f7330fcd96..2d6b350c8fc0 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_1_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -211,7 +211,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -219,9 +219,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np1_tpetra.gold
index d9a648f67204..934d6cd4ae65 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np4_tpetra.gold
index 5afd6852a376..b638f7c8bec2 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_5_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np1_tpetra.gold
index f19941336bb3..4da27c45ddc9 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np4_tpetra.gold
index 3c8a3358fe1c..4ffd5cdc913b 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_6_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -208,7 +208,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -216,9 +216,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np1_tpetra.gold
index b6f08d3f32da..d44340395aa0 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np4_tpetra.gold
index 29d186b523cc..467a4d8d697e 100644
--- a/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/operator_solve_7_np4_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesDeterministic (Phase 1 (main))
 BuildAggregatesDeterministic (Phase 2a (secondary))
 BuildAggregatesDeterministic (Phase 2b (expansion))
 BuildAggregatesDeterministic (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 1   [unused]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/pg1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/pg1_tpetra.gold
index 7c5e0f92e821..4d828d342bfa 100644
--- a/packages/muelu/test/interface/kokkos/Output/pg1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/pg1_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/pg2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/pg2_tpetra.gold
index 7c5e0f92e821..4d828d342bfa 100644
--- a/packages/muelu/test/interface/kokkos/Output/pg2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/pg2_tpetra.gold
@@ -37,7 +37,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/repartition1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/repartition1_np4_tpetra.gold
index a6f249e8fb18..c47d32e1bddb 100644
--- a/packages/muelu/test/interface/kokkos/Output/repartition1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/repartition1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/repartition1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/repartition1_tpetra.gold
index 6e69d83b769f..17cfd1bcbafe 100644
--- a/packages/muelu/test/interface/kokkos/Output/repartition1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/repartition1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/repartition3_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/repartition3_np4_tpetra.gold
index 9b8a8497cdf3..90a86a6d6a7e 100644
--- a/packages/muelu/test/interface/kokkos/Output/repartition3_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/repartition3_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -295,7 +295,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/repartition3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/repartition3_tpetra.gold
index 29a82dfd1e4b..45c1862fe800 100644
--- a/packages/muelu/test/interface/kokkos/Output/repartition3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/repartition3_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/repartition4_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/repartition4_np4_tpetra.gold
index 3609331a0a65..b721c2cdfc2e 100644
--- a/packages/muelu/test/interface/kokkos/Output/repartition4_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/repartition4_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -294,7 +294,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         4  
+  2  1112  3346   3.01     3.00         4  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/repartition4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/repartition4_tpetra.gold
index 4e2a3e5f2eeb..cf5b1cca0c4f 100644
--- a/packages/muelu/test/interface/kokkos/Output/repartition4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/repartition4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_np4_tpetra.gold
index c222dc6194a4..11c2d72caa87 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -283,7 +283,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -327,7 +327,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_tpetra.gold
index b00b61c957da..12248d63ccf7 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_np4_tpetra.gold
index 2b055cebc0f7..f6b78985e5f9 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -301,7 +301,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_tpetra.gold
index 72a7e51744c1..6e533dde78b1 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-RAP-2_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_np4_tpetra.gold
index 7415d2ff7c60..f5028d31e11b 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -387,7 +387,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_tpetra.gold
index 7edab5dd70ea..316c9364a9f4 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-RP-2_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-S-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-S-1_np4_tpetra.gold
index 8c94cc12bfcd..43f77b391179 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-S-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-S-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -283,7 +283,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -334,7 +334,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -342,9 +342,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -470,7 +470,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -478,9 +478,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -577,7 +577,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-S-1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-S-1_tpetra.gold
index 2204622fbc8a..3f311ecc547f 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-S-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-S-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -345,7 +345,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -353,9 +353,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -481,7 +481,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -489,9 +489,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-full-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-full-1_np4_tpetra.gold
index 241fab28d4d9..a38c7562e850 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-full-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-full-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -283,7 +283,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -308,7 +308,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-full-1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-full-1_tpetra.gold
index f8240f7d2b36..181c0b497fdb 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-full-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-full-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-none_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-none_np4_tpetra.gold
index 82c8b23e9dde..df103205fe27 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-none_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-none_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -336,7 +336,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -344,9 +344,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -472,7 +472,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -480,9 +480,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -581,7 +581,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-none_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-none_tpetra.gold
index 45b6800b8499..1a1e294c5d26 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-none_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-none_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -345,7 +345,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -353,9 +353,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -481,7 +481,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -489,9 +489,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_np4_tpetra.gold
index 6710e7b44baf..ae89b3aba95e 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -483,7 +483,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_tpetra.gold
index b6463572088e..d46263a1986e 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-tP-1_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_np4_tpetra.gold
index c1217b433a5d..91af4fb9044e 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_np4_tpetra.gold
@@ -41,7 +41,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -178,7 +178,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -186,9 +186,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -287,7 +287,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -425,7 +425,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -433,9 +433,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -534,7 +534,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_tpetra.gold
index d0a200744e69..948089d7e0c4 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-tP-2_tpetra.gold
@@ -41,7 +41,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -49,9 +49,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -178,7 +178,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -186,9 +186,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -434,7 +434,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -442,9 +442,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_np4_tpetra.gold
index 8fd9b7d222a3..76078f5ddeec 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -285,7 +285,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -423,7 +423,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -431,9 +431,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -532,7 +532,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_tpetra.gold
index 6998c0daaec1..01c4db11e1dc 100644
--- a/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/reuse-tP-3_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -176,7 +176,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -184,9 +184,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -432,7 +432,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -440,9 +440,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother10_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother10_tpetra.gold
index 7ecaf32b845e..358824b63971 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother10_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother10_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother11_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother11_tpetra.gold
index 4a348d927e22..214f41489c2a 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother11_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother11_tpetra.gold
@@ -56,7 +56,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -64,9 +64,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother12_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother12_tpetra.gold
index 01775166210a..0d938c6180e6 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother12_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother12_tpetra.gold
@@ -31,7 +31,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -39,9 +39,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -112,7 +112,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -120,9 +120,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -193,7 +193,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -201,9 +201,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -248,7 +248,7 @@ keep smoother data = 0   [default]
 PreSmoother data = Teuchos::RCP<MueLu::SmootherPrototype<ignored> >{ptr=0,node=0,strong_count=0,weak_count=0}   [default]
 PostSmoother data = Teuchos::RCP<MueLu::SmootherPrototype<ignored> >{ptr=0,node=0,strong_count=0,weak_count=0}   [default]
 smoother -> 
- chebyshev: ratio eigenvalue = 2.99461
+ chebyshev: ratio eigenvalue = 3.01084
  chebyshev: boost factor = 1.1   [unused]
  chebyshev: min diagonal value = 2.22045e-16   [default]
  chebyshev: degree = 1   [default]
@@ -274,7 +274,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -282,9 +282,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -329,7 +329,7 @@ keep smoother data = 0   [default]
 PreSmoother data = Teuchos::RCP<MueLu::SmootherPrototype<ignored> >{ptr=0,node=0,strong_count=0,weak_count=0}   [default]
 PostSmoother data = Teuchos::RCP<MueLu::SmootherPrototype<ignored> >{ptr=0,node=0,strong_count=0,weak_count=0}   [default]
 smoother -> 
- chebyshev: ratio eigenvalue = 2.99194
+ chebyshev: ratio eigenvalue = 3.04959
  chebyshev: boost factor = 1.1   [unused]
  chebyshev: min diagonal value = 2.22045e-16   [default]
  chebyshev: degree = 1   [default]
@@ -355,7 +355,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -363,9 +363,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -428,9 +428,9 @@ level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  1  
   1  3333  9997   3.00     3.00         1  
   2  1111  3331   3.00     3.00         1  
-  3  371   1111   2.99     2.99         1  
-  4  124   370    2.98     2.99         1  
-  5  42    124    2.95     2.95         1  
+  3  369   1105   2.99     3.01         1  
+  4  121   361    2.98     3.05         1  
+  5  36    106    2.94     3.36         1  
 
 Smoother (level 0) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 1, lambdaMax = <ignored>, alpha: 2, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
@@ -438,9 +438,9 @@ Smoother (level 1) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: tr
 
 Smoother (level 2) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 1, lambdaMax = <ignored>, alpha: 4, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [1111, 1111], Global nnz: 3331}
 
-Smoother (level 3) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 1, lambdaMax = <ignored>, alpha: 2.99461, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [371, 371], Global nnz: 1111}
+Smoother (level 3) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 1, lambdaMax = <ignored>, alpha: 3.01084, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [369, 369], Global nnz: 1105}
 
-Smoother (level 4) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 1, lambdaMax = <ignored>, alpha: 2.99194, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [124, 124], Global nnz: 370}
+Smoother (level 4) both : "Ifpack2::Chebyshev": {Initialized: true, Computed: true, "Ifpack2::Details::Chebyshev":{degree: 1, lambdaMax = <ignored>, alpha: 3.04959, lambdaMin = <ignored>, boost factor: 1.1}, Global matrix dimensions: [121, 121], Global nnz: 361}
 
 Smoother (level 5) pre  : <Direct> solver interface
 Smoother (level 5) post : no smoother
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother13_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother13_tpetra.gold
index 35d80ca9aea9..2417f88e2e66 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother13_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother13_tpetra.gold
@@ -38,7 +38,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother1_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother2_tpetra.gold
index 51caf4695c24..a67cab4ffbd6 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother2_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother3_tpetra.gold
index dd796fbdabad..8f3a7b0636bd 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother3_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother4_tpetra.gold
index f5f426f6b623..4510989a7c73 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother4_tpetra.gold
@@ -18,7 +18,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -26,9 +26,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -86,7 +86,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -94,9 +94,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother5_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother5_tpetra.gold
index bb5f7dbd8955..54243a9e8e6a 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother5_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother5_tpetra.gold
@@ -31,7 +31,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -39,9 +39,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -112,7 +112,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -120,9 +120,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother6_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother6_tpetra.gold
index 404a13da5738..ed140afb5165 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother6_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother6_tpetra.gold
@@ -25,7 +25,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -33,9 +33,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -100,7 +100,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -108,9 +108,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/smoother9_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/smoother9_tpetra.gold
index ef1a7b8c7f93..75c42b869800 100644
--- a/packages/muelu/test/interface/kokkos/Output/smoother9_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/smoother9_tpetra.gold
@@ -38,7 +38,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -46,9 +46,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -126,7 +126,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -134,9 +134,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/sync1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/sync1_tpetra.gold
index 7700f42859d4..b9d85fd3a6d3 100644
--- a/packages/muelu/test/interface/kokkos/Output/sync1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/sync1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -124,7 +124,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -132,9 +132,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/transpose1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/transpose1_tpetra.gold
index 99b828f36504..3e957f860475 100644
--- a/packages/muelu/test/interface/kokkos/Output/transpose1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/transpose1_tpetra.gold
@@ -37,7 +37,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -45,9 +45,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -120,7 +120,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -128,9 +128,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/transpose2_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/transpose2_np4_tpetra.gold
index 7842282871db..947ecd9d84a1 100644
--- a/packages/muelu/test/interface/kokkos/Output/transpose2_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/transpose2_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/transpose2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/transpose2_tpetra.gold
index bc8b2deac930..5cc73d12dacb 100644
--- a/packages/muelu/test/interface/kokkos/Output/transpose2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/transpose2_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/transpose3_np4_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/transpose3_np4_tpetra.gold
index 0ea82721bb82..9c7d93557886 100644
--- a/packages/muelu/test/interface/kokkos/Output/transpose3_np4_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/transpose3_np4_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -257,7 +257,7 @@ Cycle type          = V
 level  rows  nnz    nnz/row  c ratio  procs
   0  9999  29995  3.00                  4  
   1  3335  10015  3.00     3.00         4  
-  2  1112  3340   3.00     3.00         1  
+  2  1112  3346   3.01     3.00         1  
 
 Smoother (level 0) both : "Ifpack2::Relaxation": {Initialized: true, Computed: true, Type: Symmetric Gauss-Seidel, sweeps: 1, damping factor: 1, Global matrix dimensions: [9999, 9999], Global nnz: 29995}
 
diff --git a/packages/muelu/test/interface/kokkos/Output/transpose3_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/transpose3_tpetra.gold
index 7fb87ce3b349..2be8ce9b15b3 100644
--- a/packages/muelu/test/interface/kokkos/Output/transpose3_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/transpose3_tpetra.gold
@@ -40,7 +40,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -48,9 +48,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -162,7 +162,7 @@ lightweight wrap = 1
 Build (MueLu::TentativePFactory_kokkos)
 Build (MueLu::UncoupledAggregationFactory_kokkos)
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -170,9 +170,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/unsmoothed1_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/unsmoothed1_tpetra.gold
index 6f9ce8a6a4a8..3e504ae003a4 100644
--- a/packages/muelu/test/interface/kokkos/Output/unsmoothed1_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/unsmoothed1_tpetra.gold
@@ -36,7 +36,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -44,9 +44,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -116,7 +116,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -124,9 +124,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
diff --git a/packages/muelu/test/interface/kokkos/Output/unsmoothed2_tpetra.gold b/packages/muelu/test/interface/kokkos/Output/unsmoothed2_tpetra.gold
index 1b9de4442730..9cf92e6d18c5 100644
--- a/packages/muelu/test/interface/kokkos/Output/unsmoothed2_tpetra.gold
+++ b/packages/muelu/test/interface/kokkos/Output/unsmoothed2_tpetra.gold
@@ -36,7 +36,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -44,9 +44,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]
@@ -116,7 +116,7 @@ filtered matrix: reuse eigenvalue = 1   [default]
 lightweight wrap = 1
 
 BuildAggregates (Phase - (Dirichlet))
-BuildAggregatesSerial (Phase 1 (main))
+BuildAggregatesRandom (Phase 1 (main))
 BuildAggregatesRandom (Phase 2a (secondary))
 BuildAggregatesRandom (Phase 2b (expansion))
 BuildAggregatesRandom (Phase 3 (cleanup))
@@ -124,9 +124,9 @@ aggregation: max agg size = -1   [default]
 aggregation: min agg size = 2   [default]
 aggregation: max selected neighbors = 0   [default]
 aggregation: ordering = natural   [default]
-aggregation: enable phase 1 = 1   [default]
-aggregation: phase 1 algorithm = Serial   [default]
 aggregation: deterministic = 0   [default]
+aggregation: coloring algorithm = default   [default]
+aggregation: enable phase 1 = 1   [default]
 aggregation: enable phase 2a = 1   [default]
 aggregation: enable phase 2b = 1   [default]
 aggregation: enable phase 3 = 1   [default]

From a7534b01e3d5dbcffd7155d2798848c42a2f768f Mon Sep 17 00:00:00 2001
From: Christian Glusa <caglusa@sandia.gov>
Date: Thu, 21 Nov 2019 19:42:25 -0700
Subject: [PATCH 15/21] MueLu RefMaxwell: Print more matrix stats

---
 .../adapters/xpetra/MueLu_RefMaxwell_def.hpp  | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/packages/muelu/adapters/xpetra/MueLu_RefMaxwell_def.hpp b/packages/muelu/adapters/xpetra/MueLu_RefMaxwell_def.hpp
index 3aa7bb4d7977..beba30e22c6c 100644
--- a/packages/muelu/adapters/xpetra/MueLu_RefMaxwell_def.hpp
+++ b/packages/muelu/adapters/xpetra/MueLu_RefMaxwell_def.hpp
@@ -259,6 +259,13 @@ namespace MueLu {
       M1_Matrix_ = fineLevel.Get< RCP<Matrix> >("A",ThreshFact.get());
     }
 
+    if (IsPrint(Statistics2)) {
+      RCP<ParameterList> params = rcp(new ParameterList());;
+      params->set("printLoadBalancingInfo", true);
+      params->set("printCommInfo",          true);
+      GetOStream(Statistics2) << PerfUtils::PrintMatrixInfo(*SM_Matrix_, "SM_Matrix", params);
+    }
+
     if (!reuse) {
       // clean rows associated with boundary conditions
       // Find rows with only 1 or 2 nonzero entries, record them in BCrows_.
@@ -621,6 +628,12 @@ namespace MueLu {
 #endif
       if (!AH_.is_null()) {
         int oldRank = SetProcRankVerbose(AH_->getDomainMap()->getComm()->getRank());
+        if (IsPrint(Statistics2)) {
+          RCP<ParameterList> params = rcp(new ParameterList());;
+          params->set("printLoadBalancingInfo", true);
+          params->set("printCommInfo",          true);
+          GetOStream(Statistics2) << PerfUtils::PrintMatrixInfo(*AH_, "AH", params);
+        }
         if (!reuse) {
           ParameterList& userParamList = precList11_.sublist("user data");
           userParamList.set<RCP<RealValuedMultiVector> >("Coordinates", CoordsH_);
@@ -857,6 +870,12 @@ namespace MueLu {
       if (!A22_.is_null()) {
         A22_->setObjectLabel("RefMaxwell (2,2)");
         int oldRank = SetProcRankVerbose(A22_->getDomainMap()->getComm()->getRank());
+        if (IsPrint(Statistics2)) {
+          RCP<ParameterList> params = rcp(new ParameterList());;
+          params->set("printLoadBalancingInfo", true);
+          params->set("printCommInfo",          true);
+          GetOStream(Statistics2) << PerfUtils::PrintMatrixInfo(*A22_, "A22", params);
+        }
         if (!reuse) {
           ParameterList& userParamList = precList22_.sublist("user data");
           userParamList.set<RCP<RealValuedMultiVector> >("Coordinates", Coords_);

From 220e0bfab3876f97aa5319590d1b0775da62bccf Mon Sep 17 00:00:00 2001
From: "Roscoe A. Bartlett" <rabartl@sandia.gov>
Date: Fri, 22 Nov 2019 08:02:56 -0700
Subject: [PATCH 16/21] Reduce to ctest -j4 in all documentation (#6052)

To be safe, and to match with all of the CUDA builds, I reduced the default
parallel level for ctest to ctest -j4.  This should avoid problems with GPU
overloading.
---
 cmake/std/atdm/README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/cmake/std/atdm/README.md b/cmake/std/atdm/README.md
index 027cd8e9d2ea..fd822d3e707b 100644
--- a/cmake/std/atdm/README.md
+++ b/cmake/std/atdm/README.md
@@ -48,7 +48,7 @@ $ cmake \
 
 $ make NP=16  # Uses ninja -j16
 
-$ ctest -j16  # Might need to be run with srun or some other command, see below
+$ ctest -j4  # Might need to be run with srun or some other command, see below
 ```
 
 The command:
@@ -640,7 +640,7 @@ $ cmake \
 
 $ make NP=16
 
-$ bsub -x -Is -q rhel7F -n 16 ctest -j16
+$ bsub -x -Is -q rhel7F -n 16 ctest -j4
 ```
 
 The ATDM configuration of Trilinos is set up to run on the Firestone nodes
@@ -688,7 +688,7 @@ $ cmake \
 
 $ make NP=16
 
-$ srun ctest -j16
+$ srun ctest -j4
 ```
 
 **NOTE:** While the above example shows loading the environment, configuring
@@ -732,7 +732,7 @@ $ cmake \
 
 $ make NP=16
 
-$ salloc -N1 --time=0:20:00 --account=<YOUR_WCID> ctest -j16
+$ salloc -N1 --time=0:20:00 --account=<YOUR_WCID> ctest -j4
 ```
 
 To get information on <YOUR_WCID> used above, there is a WC tool tab on
@@ -1013,7 +1013,7 @@ $ cmake \
 
 $ make NP=20
 
-$ bsub -x -Is -n 20 ctest -j20
+$ bsub -x -Is -n 20 ctest -j4
 ```
 
 **NOTE:** While the above example shows loading the environment, configuring

From f3a620ea0a906df58f57070f01cae8cdf7603b26 Mon Sep 17 00:00:00 2001
From: Greg Sjaardema <gdsjaar@sandia.gov>
Date: Fri, 22 Nov 2019 08:18:20 -0700
Subject: [PATCH 17/21] SEACAS: Bug fix since snapshot

* Conjoin -- fix time tolerance testing for inter-database times
* Aprepro -- fix eating of newline following endswitch
---
 .../applications/aprepro/test_standard.out    |    1 +
 .../seacas/applications/conjoin/CJ_Version.h  |    4 +-
 .../seacas/applications/conjoin/Conjoin.C     |    5 +-
 .../libraries/aprepro_lib/apr_aprepro.cc      |    2 +-
 .../libraries/aprepro_lib/apr_scanner.cc      | 4994 +++++++++--------
 .../seacas/libraries/aprepro_lib/aprepro.ll   |    9 +-
 .../libraries/aprepro_lib/test_standard.out   |    1 +
 7 files changed, 2715 insertions(+), 2301 deletions(-)

diff --git a/packages/seacas/applications/aprepro/test_standard.out b/packages/seacas/applications/aprepro/test_standard.out
index a28e7649c777..5dc9cfdc28d0 100644
--- a/packages/seacas/applications/aprepro/test_standard.out
+++ b/packages/seacas/applications/aprepro/test_standard.out
@@ -82,6 +82,7 @@ $ Test switch
 This should echo
 3.141592654
 
+
 This should be equal to PI --  3.141592654
 $ Test int and [] (shortcut for int)
 5	-5
diff --git a/packages/seacas/applications/conjoin/CJ_Version.h b/packages/seacas/applications/conjoin/CJ_Version.h
index 1deaf2bebcaa..f4b3d861a0a6 100644
--- a/packages/seacas/applications/conjoin/CJ_Version.h
+++ b/packages/seacas/applications/conjoin/CJ_Version.h
@@ -33,8 +33,8 @@
 
 static char const *qainfo[] = {
     "conjoin",
-    "2019/10/07",
-    "1.4.4",
+    "2019/11/19",
+    "1.4.5",
 };
 
 #endif // SEACAS_Version_h
diff --git a/packages/seacas/applications/conjoin/Conjoin.C b/packages/seacas/applications/conjoin/Conjoin.C
index c2515388dd3a..2faa7c0783e8 100644
--- a/packages/seacas/applications/conjoin/Conjoin.C
+++ b/packages/seacas/applications/conjoin/Conjoin.C
@@ -530,9 +530,8 @@ int conjoin(Excn::SystemInterface &interFace, T /* dummy */, INT /* dummy int */
         }
       }
       local_mesh[p - 1].timestepCount = i;
-      if (i > 0) {
-        t_min = t_min < times[0] ? t_min : times[0];
-      }
+      t_min = t_min < times[0] ? t_min : times[0];
+
       if (!used) {
         std::string part = "Part " + std::to_string(p) + ": ";
         part += interFace.inputFiles_[p - 1];
diff --git a/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc b/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc
index 921727a4cd0e..2a5ecf529f77 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_aprepro.cc
@@ -51,7 +51,7 @@
 
 namespace {
   const unsigned int HASHSIZE       = 5939;
-  const char *       version_string = "5.13 (2019/10/17)";
+  const char *       version_string = "5.14 (2019/11/20)";
 
   void output_copyright();
 
diff --git a/packages/seacas/libraries/aprepro_lib/apr_scanner.cc b/packages/seacas/libraries/aprepro_lib/apr_scanner.cc
index 4b27323fd02f..d1de36222067 100644
--- a/packages/seacas/libraries/aprepro_lib/apr_scanner.cc
+++ b/packages/seacas/libraries/aprepro_lib/apr_scanner.cc
@@ -1,4 +1,7 @@
-#define YY_INT_ALIGNED short int
+
+#line 3 "apr_scanner.cc"
+
+#define  YY_INT_ALIGNED short int
 
 /* A lexical scanner generated by flex */
 
@@ -19,13 +22,13 @@
 #endif
 
 /* %if-c++-only */
-/* The c++ scanner is a mess. The FlexLexer.h header file relies on the
- * following macro. This is required in order to pass the c++-multiple-scanners
- * test in the regression suite. We get reports that it breaks inheritance.
- * We will address this in a future release of flex, or omit the C++ scanner
- * altogether.
- */
-#define yyFlexLexer SEAMSFlexLexer
+    /* The c++ scanner is a mess. The FlexLexer.h header file relies on the
+     * following macro. This is required in order to pass the c++-multiple-scanners
+     * test in the regression suite. We get reports that it breaks inheritance.
+     * We will address this in a future release of flex, or omit the C++ scanner
+     * altogether.
+     */
+    #define yyFlexLexer SEAMSFlexLexer
 /* %endif */
 
 /* %if-c-only */
@@ -52,57 +55,57 @@
 
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 
-#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 
 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types.
+ * if you want the limit (max/min) macros for int types. 
  */
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS 1
 #endif
 
 #include <inttypes.h>
-typedef int8_t   flex_int8_t;
-typedef uint8_t  flex_uint8_t;
-typedef int16_t  flex_int16_t;
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
 typedef uint16_t flex_uint16_t;
-typedef int32_t  flex_int32_t;
+typedef int32_t flex_int32_t;
 typedef uint32_t flex_uint32_t;
 #else
-typedef signed char        flex_int8_t;
-typedef short int          flex_int16_t;
-typedef int                flex_int32_t;
-typedef unsigned char      flex_uint8_t;
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
 typedef unsigned short int flex_uint16_t;
-typedef unsigned int       flex_uint32_t;
+typedef unsigned int flex_uint32_t;
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
-#define INT8_MIN (-128)
+#define INT8_MIN               (-128)
 #endif
 #ifndef INT16_MIN
-#define INT16_MIN (-32767 - 1)
+#define INT16_MIN              (-32767-1)
 #endif
 #ifndef INT32_MIN
-#define INT32_MIN (-2147483647 - 1)
+#define INT32_MIN              (-2147483647-1)
 #endif
 #ifndef INT8_MAX
-#define INT8_MAX (127)
+#define INT8_MAX               (127)
 #endif
 #ifndef INT16_MAX
-#define INT16_MAX (32767)
+#define INT16_MAX              (32767)
 #endif
 #ifndef INT32_MAX
-#define INT32_MAX (2147483647)
+#define INT32_MAX              (2147483647)
 #endif
 #ifndef UINT8_MAX
-#define UINT8_MAX (255U)
+#define UINT8_MAX              (255U)
 #endif
 #ifndef UINT16_MAX
-#define UINT16_MAX (65535U)
+#define UINT16_MAX             (65535U)
 #endif
 #ifndef UINT32_MAX
-#define UINT32_MAX (4294967295U)
+#define UINT32_MAX             (4294967295U)
 #endif
 
 #endif /* ! C99 */
@@ -113,11 +116,11 @@ typedef unsigned int       flex_uint32_t;
 
 /* %if-c++-only */
 /* begin standard C++ headers. */
-#include <cstdio>
+#include <iostream> 
+#include <errno.h>
 #include <cstdlib>
+#include <cstdio>
 #include <cstring>
-#include <errno.h>
-#include <iostream>
 /* end standard C++ headers. */
 /* %endif */
 
@@ -126,15 +129,15 @@ typedef unsigned int       flex_uint32_t;
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
-#else /* ! __cplusplus */
+#else	/* ! __cplusplus */
 
 /* C99 requires __STDC__ to be defined as 1. */
-#if defined(__STDC__)
+#if defined (__STDC__)
 
 #define YY_USE_CONST
 
-#endif /* defined (__STDC__) */
-#endif /* ! __cplusplus */
+#endif	/* defined (__STDC__) */
+#endif	/* ! __cplusplus */
 
 #ifdef YY_USE_CONST
 #define yyconst const
@@ -155,7 +158,7 @@ typedef unsigned int       flex_uint32_t;
  * we want to instead treat it as an 8-bit unsigned char, hence the
  * double cast.
  */
-#define YY_SC_TO_UI(c) ((unsigned int)(unsigned char)c)
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 /* %ok-for-header */
 
 /* %if-reentrant */
@@ -175,14 +178,14 @@ typedef unsigned int       flex_uint32_t;
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
-#define YY_START (((yy_start)-1) / 2)
+#define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
 
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart(yyin)
+#define YY_NEW_FILE yyrestart( yyin  )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
@@ -193,7 +196,7 @@ typedef unsigned int       flex_uint32_t;
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
  */
-#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 #define YY_TYPEDEF_YY_BUFFER_STATE
@@ -218,88 +221,92 @@ extern yy_size_t yyleng;
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-#define YY_LESS_LINENO(n)
-
+    #define YY_LESS_LINENO(n)
+    
 /* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n)                                                                                  \
-  do {                                                                                             \
-    /* Undo effects of setting up yytext. */                                                       \
-    int yyless_macro_arg = (n);                                                                    \
-    YY_LESS_LINENO(yyless_macro_arg);                                                              \
-    *yy_cp                                = (yy_hold_char);                                        \
-    YY_RESTORE_YY_MORE_OFFSET(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ;        \
-    YY_DO_BEFORE_ACTION; /* set up yytext again */                                                 \
-  } while (0)
-
-#define unput(c) yyunput(c, (yytext_ptr))
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = (yy_hold_char); \
+		YY_RESTORE_YY_MORE_OFFSET \
+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, (yytext_ptr)  )
 
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
-{
-  /* %if-c-only */
-  /* %endif */
-
-  /* %if-c++-only */
-  std::istream *yy_input_file;
-  /* %endif */
-
-  char *yy_ch_buf;  /* input buffer */
-  char *yy_buf_pos; /* current position in input buffer */
-
-  /* Size of input buffer in bytes, not including room for EOB
-   * characters.
-   */
-  yy_size_t yy_buf_size;
-
-  /* Number of characters read into yy_ch_buf, not including EOB
-   * characters.
-   */
-  yy_size_t yy_n_chars;
-
-  /* Whether we "own" the buffer - i.e., we know we created it,
-   * and can realloc() it to grow it, and should free() it to
-   * delete it.
-   */
-  int yy_is_our_buffer;
-
-  /* Whether this is an "interactive" input source; if so, and
-   * if we're using stdio for input, then we want to use getc()
-   * instead of fread(), to make sure we stop fetching input after
-   * each newline.
-   */
-  int yy_is_interactive;
-
-  /* Whether we're considered to be at the beginning of a line.
-   * If so, '^' rules will be active on the next match, otherwise
-   * not.
-   */
-  int yy_at_bol;
-
-  int yy_bs_lineno; /**< The line count. */
-  int yy_bs_column; /**< The column count. */
-
-  /* Whether to try to fill the input buffer when we reach the
-   * end of it.
-   */
-  int yy_fill_buffer;
+	{
+/* %if-c-only */
+/* %endif */
 
-  int yy_buffer_status;
+/* %if-c++-only */
+	std::istream* yy_input_file;
+/* %endif */
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	yy_size_t yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
 
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
-  /* When an EOF's been seen but there's still some text to process
-   * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-   * shouldn't try reading from the input source any more.  We might
-   * still have a bunch of tokens to match, though, because of
-   * possible backing-up.
-   *
-   * When we actually see the EOF, we change the status to "new"
-   * (via yyrestart()), so that the user can continue scanning by
-   * just pointing yyin at a new input file.
-   */
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
 #define YY_BUFFER_EOF_PENDING 2
-};
+
+	};
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
 /* %if-c-only Standard (non-C++) definition */
@@ -317,7 +324,9 @@ struct yy_buffer_state
  *
  * Returns the top of the stack, or NULL.
  */
-#define YY_CURRENT_BUFFER ((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL)
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
 
 /* Same as previous macro, but useful when we know that the buffer stack is not
  * NULL or when we need an lvalue. For internal use only.
@@ -333,29 +342,31 @@ struct yy_buffer_state
 /* %endif */
 /* %endif */
 
-void *SEAMSalloc(yy_size_t);
-void *SEAMSrealloc(void *, yy_size_t);
-void  SEAMSfree(void *);
+void *SEAMSalloc (yy_size_t  );
+void *SEAMSrealloc (void *,yy_size_t  );
+void SEAMSfree (void *  );
 
 #define yy_new_buffer yy_create_buffer
 
-#define yy_set_interactive(is_interactive)                                                         \
-  {                                                                                                \
-    if (!YY_CURRENT_BUFFER) {                                                                      \
-      yyensure_buffer_stack();                                                                     \
-      YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE);                              \
-    }                                                                                              \
-    YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive;                                  \
-  }
-
-#define yy_set_bol(at_bol)                                                                         \
-  {                                                                                                \
-    if (!YY_CURRENT_BUFFER) {                                                                      \
-      yyensure_buffer_stack();                                                                     \
-      YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE);                              \
-    }                                                                                              \
-    YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol;                                                  \
-  }
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
 
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
@@ -377,14 +388,14 @@ typedef unsigned char YY_CHAR;
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
-#define YY_DO_BEFORE_ACTION                                                                        \
-  (yytext_ptr) = yy_bp;                                                                            \
-  /* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */                         \
-  yyleng         = (size_t)(yy_cp - yy_bp);                                                        \
-  (yy_hold_char) = *yy_cp;                                                                         \
-  *yy_cp         = '\0';                                                                           \
-  /* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */                        \
-  (yy_c_buf_p) = yy_cp;
+#define YY_DO_BEFORE_ACTION \
+	(yytext_ptr) = yy_bp; \
+/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
+	yyleng = (size_t) (yy_cp - yy_bp); \
+	(yy_hold_char) = *yy_cp; \
+	*yy_cp = '\0'; \
+/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
+	(yy_c_buf_p) = yy_cp;
 
 /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
 #define YY_NUM_RULES 102
@@ -392,573 +403,898 @@ typedef unsigned char YY_CHAR;
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
-{
-  flex_int32_t yy_verify;
-  flex_int32_t yy_nxt;
-};
-static yyconst flex_int16_t yy_accept[703] = {
-    0,  0,  0,   52,  52,  0,   0,   41,  41,  0,   0,  2,   2,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   0,   103, 100, 100, 101, 98, 99,  99,  99,  100, 95,  52,
-    72, 87, 100, 69,  100, 100, 73,  74,  65,  63,  75, 64,  51,  68,  50,  77,  76,
-    79, 54, 80,  78,  53,  53,  53,  88,  89,  70,  95, 100, 92,  66,  100, 100, 98,
-    99, 99, 99,  100, 95,  44,  44,  45,  41,  44,  41, 41,  41,  41,  44,  44,  100,
-    3,  3,  4,   2,   3,   2,   2,   2,   2,   3,   3,  100, 100, 35,  98,  99,
-
-    99, 99, 100, 95,  100, 100, 98,  100, 100, 99,  99, 99,  100, 95,  100, 100, 19,
-    98, 99, 99,  99,  100, 95,  100, 100, 23,  98,  99, 99,  99,  100, 95,  100, 100,
-    27, 98, 99,  99,  99,  100, 95,  0,   0,   99,  99, 99,  93,  94,  0,   0,   0,
-    0,  0,  0,   0,   0,   0,   0,   52,  0,   84,  0,  90,  85,  0,   91,  71,  57,
-    61, 55, 62,  56,  51,  0,   67,  58,  51,  50,  0,  81,  83,  82,  53,  53,  53,
-    59, 0,  86,  0,   0,   0,   0,   99,  99,  99,  93, 94,  0,   0,   0,
-
-    41, 41, 41,  41,  41,  42,  43,  0,   0,   0,   0,  2,   2,   2,   2,   2,   0,
-    0,  35, 0,   0,   99,  99,  99,  93,  94,  0,   0,  0,   0,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   99,  99,  99,  93,  94,  0,  0,   19,  0,   0,   99,  99,
-    99, 93, 94,  0,   0,   0,   0,   23,  0,   0,   99, 99,  99,  93,  94,  0,   0,
-    0,  0,  27,  0,   0,   99,  99,  99,  93,  94,  0,  0,   0,   0,   0,   99,  99,
-    0,  0,  0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   0,   60,  0,
-
-    51, 0,  50,  53,  53,  0,   49,  99,  99,  0,   0,  41,  41,  0,   0,   0,   2,
-    2,  0,  99,  99,  0,   0,   0,   0,   0,   13,  0,  0,   0,   0,   0,   0,   0,
-    99, 99, 0,   0,   99,  99,  0,   0,   0,   0,   99, 99,  0,   0,   0,   0,   99,
-    99, 0,  0,   0,   0,   0,   0,   96,  97,  0,   0,  0,   0,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   0,   53,  53,  49,  96,  97, 0,   0,   41,  41,  0,   0,
-    0,  37, 0,   0,   2,   2,   0,   96,  97,  0,   0,  0,   0,   0,   0,
-
-    0,  15, 0,   0,   13,  0,   0,   14,  0,   96,  97, 0,   0,   96,  97,  0,   0,
-    0,  0,  96,  97,  0,   0,   0,   0,   96,  97,  0,  0,   0,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   0,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   0,   33,  0,   0,   0,   0,  0,   0,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   0,   0,   0,   6,   0,
-    0,  0,  0,   0,   0,   0,   12,  0,   0,   0,   0,  0,   0,   0,   0,
-
-    0,  0,  0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   0,   0,   0,   0,   0,
-    0,  0,  0,   0,   0,   0,   0,   24,  0,   0,   0,  0,   0,   39,  0,   0,   0,
-    29, 0,  0,   0,   0,   0,   0,   0,   0,   0,   0,  0,   36,  0,   0,   0,   35,
-    0,  0,  0,   0,   0,   0,   0,   0,   0,   19,  0,  0,   0,   17,  0,   0,   23,
-    0,  0,  0,   21,  0,   27,  0,   0,   0,   0,   0,  0,   0,   46,  0,   0,   30,
-    0,  8,  0,   0,   0,   0,   49,  0,   0,   0,   40, 0,   38,  0,   0,
-
-    31, 0,  32,  0,   0,   0,   0,   0,   0,   0,   19, 0,   0,   0,   23,  0,   0,
-    27, 0,  0,   0,   0,   0,   0,   0,   47,  0,   0,  0,   0,   39,  0,   49,  0,
-    0,  34, 0,   15,  0,   0,   0,   0,   16,  0,   0,  20,  0,   0,   0,   0,   48,
-    0,  7,  0,   0,   0,   25,  0,   46,  0,   0,   0,  15,  0,   0,   0,   0,   25,
-    0,  9,  0,   0,   0,   0,   0,   0,   0,   18,  0,  22,  0,   0,   0,   0,   0,
-    28, 0,  0,   26,  0,   0,   0,   0,   0,   0,   5,  0,   0,   10,  1,
-
-    11, 0};
-
-static yyconst flex_int32_t yy_ec[256] = {
-    0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  3,  1,  2,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  4,  5,  6,  1,  7,  8,  9,  10, 11, 12,
-    13, 14, 15, 16, 17, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 21, 22, 23, 24,
-    25, 1,  26, 27, 28, 29, 30, 31, 29, 32, 33, 29, 29, 34, 35, 36, 37, 29, 38, 39, 29,
-    40, 41, 42, 29, 43, 29, 29, 44, 45, 46, 47, 29, 1,  48, 49, 50, 51,
-
-    52, 53, 29, 54, 55, 29, 29, 56, 29, 57, 58, 59, 38, 60, 61, 62, 63, 29, 64, 43, 29,
-    29, 65, 66, 67, 68, 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1};
-
-static yyconst flex_int32_t yy_meta[69] = {0, 1, 2, 3, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                                           1, 5, 6, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-                                           5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5,
-                                           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 1, 1, 1};
-
-static yyconst flex_int16_t yy_base[752] = {
-    0,    0,    0,    68,   0,    136,  0,    204,  0,    271,  272,  337,  0,    405,  0,
-    473,  0,    541,  0,    609,  0,    677,  0,    2511, 2512, 744,  2512, 2512, 0,    2467,
-    236,  213,  808,  748,  2512, 2486, 276,  2512, 2499, 2497, 2512, 2512, 268,  269,  2512,
-    270,  265,  267,  270,  2512, 2512, 2483, 2482, 2481, 2512, 0,    2460, 247,  2512, 2512,
-    2479, 264,  2435, 2512, 2512, 2488, 749,  2487, 864,  2455, 255,  735,  737,  2512, 752,
-    2512, 753,  2512, 756,  293,  755,  756,  236,  775,  760,  2512, 761,  2512, 764,  2512,
-    767,  294,  768,  774,  237,  277,  2494, 778,  2512, 2493, 932,
-
-    2452, 264,  768,  801,  2482, 781,  2481, 989,  990,  1042, 2449, 265,  780,  810,  2488,
-    1109, 2512, 2487, 1174, 2446, 267,  784,  1111, 2485, 1241, 2512, 2484, 1306, 2443, 268,
-    787,  1112, 2482, 1373, 2512, 2481, 1438, 2440, 270,  1504, 1119, 1507, 2440, 0,    279,
-    740,  2512, 2512, 1114, 2426, 975,  771,  2422, 2442, 2448, 2425, 264,  717,  1508, 771,
-    2512, 320,  2512, 2512, 2466, 2512, 2452, 2512, 2512, 2512, 2512, 2512, 985,  997,  2512,
-    2512, 987,  993,  1008, 2512, 2512, 2512, 0,    806,  981,  2512, 268,  2512, 2462, 1511,
-    1512, 1105, 0,    985,  1092, 2461, 2460, 1116, 1515, 1244,
-
-    1516, 1519, 787,  1243, 1245, 2512, 2512, 1249, 969,  2418, 1523, 1524, 1520, 1001, 1248,
-    1250, 2440, 2466, 2512, 1527, 1375, 0,    1093, 1096, 2465, 2464, 1376, 1378, 2454, 1368,
-    1530, 1243, 1532, 1245, 1120, 1370, 1250, 1371, 1142, 0,    1097, 1098, 2453, 2452, 1372,
-    2460, 2512, 1535, 1549, 0,    1100, 1107, 2459, 2458, 1255, 1505, 1533, 2457, 2512, 1543,
-    1564, 0,    1217, 1227, 2456, 2455, 1537, 1546, 1538, 2454, 2512, 1552, 1607, 0,    1233,
-    1234, 2453, 2452, 1611, 1550, 800,  1382, 1562, 1231, 1347, 2397, 2396, 2420, 2390, 2399,
-    2414, 977,  2398, 2389, 2416, 2406, 2391, 2392, 2512, 2423,
-
-    2422, 2421, 2420, 1349, 1351, 1556, 1026, 1352, 1353, 1521, 804,  1620, 1624, 2382, 2376,
-    1623, 1625, 1626, 2397, 1354, 1355, 796,  1571, 1639, 1282, 1394, 2512, 1554, 1395, 1108,
-    1131, 1400, 1272, 1406, 1359, 1360, 1575, 1581, 1362, 1364, 1573, 1623, 1601, 1635, 1508,
-    1593, 1636, 1644, 1632, 1645, 1609, 1611, 1650, 1651, 1653, 1664, 1383, 1665, 0,    0,
-    2384, 2384, 2396, 2380, 1636, 2390, 2378, 2378, 2372, 2368, 2398, 2398, 2376, 1637, 0,
-    0,    2420, 0,    0,    1663, 1664, 1539, 1675, 2361, 2369, 1697, 2512, 2368, 2368, 1698,
-    1702, 2391, 0,    0,    1669, 1678, 1724, 2414, 1682, 1686,
-
-    1407, 2512, 1697, 1711, 2512, 1717, 1727, 2512, 1728, 0,    0,    1665, 1712, 0,    0,
-    1710, 1707, 1735, 1729, 0,    0,    1733, 1740, 1741, 1739, 0,    0,    1738, 1747, 1745,
-    1749, 1746, 1748, 2355, 2359, 1735, 2347, 2360, 2372, 2358, 2358, 2346, 1751, 2376, 2381,
-    2343, 2341, 1744, 1751, 2352, 1750, 2350, 2350, 2375, 1751, 1754, 2397, 2512, 1755, 1758,
-    1768, 1770, 1773, 1748, 1753, 1763, 1769, 1774, 1776, 1810, 1783, 1784, 1813, 1816, 1820,
-    1817, 1823, 1826, 2396, 1825, 1827, 2335, 2360, 2512, 2393, 2328, 2368, 1831, 2340, 2341,
-    1835, 2512, 2354, 2350, 2102, 2089, 1829, 1826, 1807, 2084,
-
-    1845, 2079, 2072, 2108, 1840, 1850, 1841, 1845, 1838, 1852, 2107, 1855, 1856, 1861, 2106,
-    1864, 2104, 1857, 1865, 1873, 2103, 2102, 1866, 2100, 2512, 1870, 1877, 2051, 999,  2098,
-    2512, 2097, 2072, 1881, 2512, 1885, 2046, 2029, 2062, 2032, 2031, 1892, 1897, 1894, 2089,
-    1908, 2512, 1914, 2058, 2087, 2512, 2086, 1925, 2085, 1935, 1899, 1918, 1928, 1900, 2084,
-    2512, 2083, 1910, 2081, 2512, 1912, 2080, 2512, 2079, 1914, 2078, 2512, 2077, 2512, 2076,
-    1879, 1931, 2025, 2045, 2063, 2070, 2512, 2038, 1940, 2512, 1941, 2512, 2036, 1945, 2020,
-    1951, 1945, 1947, 1963, 2066, 2512, 1970, 2512, 2033, 2062,
-
-    2512, 2061, 2512, 1975, 2060, 1959, 1977, 1979, 1932, 2059, 2512, 2058, 1953, 2057, 2512,
-    2055, 2054, 2512, 1992, 817,  1995, 2044, 1988, 2024, 1996, 2512, 2042, 1999, 2049, 1997,
-    2031, 2011, 1980, 2015, 2006, 2512, 2005, 2512, 2007, 2013, 1965, 2002, 2512, 1973, 1985,
-    2512, 2018, 1984, 1981, 2025, 2512, 1894, 2512, 1949, 1844, 1868, 2512, 2000, 1867, 1710,
-    2025, 2028, 2512, 2030, 1675, 1561, 1560, 2512, 2041, 2512, 1514, 1514, 2037, 1417, 1365,
-    2035, 1289, 2512, 1287, 2512, 2046, 1284, 1088, 1274, 1258, 2512, 1228, 1253, 2512, 1113,
-    1021, 729,  774,  772,  268,  2512, 265,  248,  2512, 2512,
-
-    2512, 2512, 2109, 2115, 2121, 2123, 2129, 2134, 2136, 2141, 2143, 2149, 2155, 2161, 2167,
-    2173, 2179, 2185, 2191, 2197, 2203, 2209, 2215, 2221, 2227, 2233, 2239, 2245, 2251, 2257,
-    2263, 2269, 2275, 2281, 2287, 2293, 2299, 2305, 2311, 2317, 2323, 2329, 2335, 2341, 2347,
-    2353, 2359, 2365, 2371, 2377, 2383};
-
-static yyconst flex_int16_t yy_def[752] = {
-    0,   702, 1,   702, 3,   702, 5,   702, 7,   1,   1,   702, 11,  702, 13,  702, 15,
-    702, 17,  702, 19,  702, 21,  702, 702, 702, 702, 702, 703, 703, 703, 702, 702, 702,
-    702, 702, 704, 702, 702, 705, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 706, 706, 706, 702, 702, 702, 702, 702, 702, 702, 707, 707, 707,
-    702, 68,  68,  707, 707, 702, 702, 702, 708, 702, 708, 709, 709, 709, 702, 702, 702,
-    702, 702, 702, 710, 702, 710, 711, 711, 711, 702, 702, 712, 712, 702, 712, 702,
-
-    100, 100, 712, 712, 713, 713, 713, 713, 713, 702, 110, 110, 713, 713, 714, 714, 702,
-    714, 702, 119, 119, 714, 714, 715, 715, 702, 715, 702, 128, 128, 715, 715, 716, 716,
-    702, 716, 702, 137, 137, 716, 716, 702, 32,  703, 703, 703, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 704, 702, 702, 705, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 706, 706, 706,
-    702, 702, 702, 707, 707, 707, 707, 68,  68,  68,  707, 707, 707, 702, 702,
-
-    708, 708, 709, 709, 709, 702, 702, 702, 702, 702, 702, 710, 710, 711, 711, 711, 702,
-    712, 702, 712, 712, 100, 100, 100, 712, 712, 712, 712, 713, 713, 713, 713, 717, 713,
-    713, 713, 713, 713, 713, 110, 110, 110, 713, 713, 713, 714, 702, 714, 714, 119, 119,
-    119, 714, 714, 714, 714, 714, 715, 702, 715, 715, 128, 128, 128, 715, 715, 715, 715,
-    715, 716, 702, 716, 716, 137, 137, 137, 716, 716, 716, 716, 716, 716, 716, 703, 703,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-
-    702, 702, 702, 706, 706, 707, 707, 68,  68,  707, 707, 709, 709, 702, 702, 702, 711,
-    711, 702, 100, 100, 712, 712, 712, 718, 717, 702, 717, 719, 713, 713, 720, 713, 713,
-    110, 110, 713, 713, 119, 119, 714, 714, 714, 714, 128, 128, 715, 715, 715, 715, 137,
-    137, 716, 716, 716, 716, 716, 716, 703, 703, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 706, 706, 702, 68,  68,  707, 707, 709, 709, 702, 702,
-    702, 702, 702, 702, 711, 711, 702, 100, 100, 712, 712, 712, 721, 712, 712,
-
-    718, 702, 718, 719, 702, 719, 720, 702, 720, 110, 110, 713, 713, 119, 119, 714, 714,
-    714, 714, 128, 128, 715, 715, 715, 715, 137, 137, 716, 716, 716, 716, 716, 716, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 707, 707, 702, 702,
-    702, 702, 702, 712, 712, 721, 702, 712, 712, 718, 719, 720, 713, 713, 714, 714, 714,
-    714, 714, 715, 715, 715, 715, 715, 716, 716, 716, 722, 716, 716, 702, 702, 702, 723,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 724, 707, 702, 702,
-
-    702, 702, 702, 725, 712, 712, 712, 726, 713, 714, 727, 714, 714, 714, 728, 715, 729,
-    715, 715, 715, 730, 731, 716, 722, 702, 716, 716, 702, 702, 723, 702, 732, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 724, 724, 733, 734, 702, 702, 702, 702, 725, 702,
-    735, 712, 736, 712, 726, 726, 737, 714, 727, 702, 738, 714, 728, 702, 715, 729, 702,
-    739, 715, 730, 702, 731, 702, 740, 716, 716, 702, 702, 702, 732, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 724, 724, 733, 733, 734, 702, 702, 702, 702, 735,
-
-    702, 736, 702, 712, 741, 742, 737, 737, 714, 738, 702, 743, 715, 739, 702, 744, 740,
-    702, 716, 716, 702, 702, 702, 702, 702, 702, 702, 702, 745, 702, 702, 733, 733, 702,
-    741, 702, 742, 702, 742, 746, 714, 743, 702, 715, 744, 702, 716, 747, 716, 702, 702,
-    702, 702, 702, 702, 745, 702, 702, 702, 702, 742, 746, 702, 746, 748, 749, 747, 702,
-    716, 702, 702, 702, 702, 750, 702, 746, 748, 702, 749, 702, 716, 751, 702, 702, 750,
-    702, 702, 751, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-
-    702, 0,   702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702};
-
-static yyconst flex_int16_t yy_nxt[2581] = {
-    0,   24,  25,  26,  25,  24,  24,  27,  24,  24,  24,  24,  24,  24,  24,  24,  24,
-    24,  24,  24,  24,  24,  24,  24,  24,  24,  28,  28,  28,  28,  29,  28,  28,  28,
-    28,  28,  28,  28,  30,  28,  28,  28,  28,  28,  24,  31,  24,  24,  28,  28,  28,
-    28,  29,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  28,  32,  24,  24,
-    24,  24,  33,  34,  33,  35,  36,  27,  37,  38,  39,  40,  41,  42,  43,  44,  45,
-    46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  55,  55,  55,  56,  55,  55,
-
-    55,  55,  55,  55,  55,  57,  55,  55,  55,  55,  55,  58,  31,  59,  60,  55,  55,
-    55,  55,  56,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  55,  61,  62,
-    63,  64,  65,  66,  26,  66,  65,  65,  67,  65,  65,  65,  65,  65,  65,  65,  65,
-    65,  65,  65,  65,  65,  65,  65,  65,  65,  65,  68,  68,  68,  68,  69,  68,  68,
-    68,  68,  68,  68,  68,  70,  68,  68,  68,  68,  68,  65,  71,  65,  65,  68,  68,
-    68,  68,  69,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
-
-    72,  65,  65,  65,  73,  74,  75,  76,  73,  73,  77,  73,  73,  73,  73,  73,  73,
-    73,  73,  73,  73,  73,  78,  73,  73,  73,  73,  73,  73,  79,  79,  79,  79,  80,
-    79,  79,  79,  79,  79,  79,  79,  81,  79,  79,  79,  79,  79,  73,  82,  73,  73,
-    79,  79,  79,  79,  80,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,  79,
-    83,  73,  73,  73,  84,  84,  84,  84,  146, 147, 163, 148, 167, 163, 169, 173, 175,
-    171, 177, 185, 178, 176, 168, 170, 172, 187, 174, 195, 202, 213, 146, 179,
-
-    206, 147, 207, 148, 224, 242, 187, 252, 264, 185, 276, 284, 144, 144, 701, 187, 174,
-    195, 217, 289, 298, 179, 163, 289, 290, 163, 224, 242, 187, 252, 264, 700, 276, 284,
-    699, 61,  61,  85,  86,  87,  88,  85,  85,  89,  85,  85,  85,  85,  85,  85,  85,
-    85,  85,  85,  85,  90,  85,  85,  85,  85,  85,  85,  91,  91,  91,  91,  92,  91,
-    91,  91,  91,  91,  91,  91,  93,  91,  91,  91,  91,  91,  85,  94,  85,  85,  91,
-    91,  91,  91,  92,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,  91,
-
-    91,  95,  85,  85,  85,  96,  97,  98,  97,  96,  96,  99,  96,  96,  96,  96,  96,
-    96,  96,  96,  96,  96,  96,  96,  96,  96,  96,  96,  96,  96,  100, 100, 100, 100,
-    101, 100, 100, 100, 100, 100, 100, 100, 102, 100, 100, 100, 100, 100, 96,  103, 96,
-    96,  100, 100, 100, 100, 101, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
-    100, 104, 96,  96,  96,  105, 106, 26,  106, 105, 105, 107, 105, 105, 105, 105, 105,
-    105, 105, 105, 105, 108, 105, 109, 105, 105, 105, 105, 105, 105, 110, 110,
-
-    110, 110, 111, 110, 110, 110, 110, 110, 110, 110, 112, 110, 110, 110, 110, 110, 105,
-    113, 105, 105, 110, 110, 110, 110, 111, 110, 110, 110, 110, 110, 110, 110, 110, 110,
-    110, 110, 110, 114, 105, 105, 105, 115, 116, 117, 116, 115, 115, 118, 115, 115, 115,
-    115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 119, 119,
-    119, 119, 120, 119, 119, 119, 119, 119, 119, 119, 121, 119, 119, 119, 119, 119, 115,
-    122, 115, 115, 119, 119, 119, 119, 120, 119, 119, 119, 119, 119, 119, 119,
-
-    119, 119, 119, 119, 119, 123, 115, 115, 115, 124, 125, 126, 125, 124, 124, 127, 124,
-    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
-    128, 128, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128, 130, 128, 128, 128, 128,
-    128, 124, 131, 124, 124, 128, 128, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128,
-    128, 128, 128, 128, 128, 132, 124, 124, 124, 133, 134, 135, 134, 133, 133, 136, 133,
-    133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
-
-    133, 133, 137, 137, 137, 137, 138, 137, 137, 137, 137, 137, 137, 137, 139, 137, 137,
-    137, 137, 137, 133, 140, 133, 133, 137, 137, 137, 137, 138, 137, 137, 137, 137, 137,
-    137, 137, 137, 137, 137, 137, 137, 141, 133, 133, 133, 142, 190, 142, 190, 159, 191,
-    159, 191, 199, 199, 199, 201, 702, 202, 202, 190, 211, 211, 211, 211, 211, 198, 212,
-    702, 292, 219, 213, 285, 293, 144, 144, 208, 213, 208, 220, 219, 220, 231, 698, 231,
-    697, 247, 144, 198, 259, 202, 230, 230, 144, 285, 696, 205, 204, 219, 196,
-
-    187, 197, 271, 219, 209, 291, 144, 210, 143, 149, 215, 149, 160, 192, 216, 190, 200,
-    200, 205, 271, 702, 230, 187, 292, 160, 160, 209, 293, 160, 210, 227, 702, 225, 228,
-    226, 150, 216, 151, 304, 245, 152, 153, 221, 154, 243, 232, 244, 356, 253, 155, 254,
-    265, 227, 266, 381, 228, 395, 150, 156, 157, 304, 245, 158, 153, 189, 189, 649, 189,
-    189, 189, 189, 189, 189, 189, 189, 190, 189, 189, 189, 189, 189, 189, 193, 193, 189,
-    189, 189, 189, 189, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
-
-    193, 193, 193, 193, 193, 193, 193, 189, 189, 189, 189, 193, 193, 193, 193, 193, 193,
-    193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 189, 189, 189, 189, 218, 218,
-    219, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 222,
-    222, 218, 218, 218, 218, 218, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222,
-    222, 222, 222, 222, 222, 222, 222, 218, 218, 218, 218, 222, 222, 222, 222, 222, 222,
-    222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 218, 218, 218, 218,
-
-    233, 236, 288, 173, 213, 173, 237, 234, 238, 177, 300, 178, 300, 305, 174, 301, 174,
-    308, 235, 239, 144, 302, 179, 302, 315, 290, 303, 367, 377, 579, 289, 290, 695, 368,
-    580, 305, 174, 190, 174, 308, 235, 239, 229, 229, 179, 229, 229, 229, 229, 229, 229,
-    229, 229, 230, 229, 229, 229, 229, 229, 229, 240, 240, 229, 229, 229, 229, 229, 240,
-    240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240,
-    229, 229, 229, 229, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240,
-
-    240, 240, 240, 240, 240, 240, 229, 229, 229, 229, 248, 247, 248, 247, 259, 149, 190,
-    149, 690, 230, 279, 271, 279, 691, 309, 320, 331, 190, 321, 335, 336, 230, 339, 330,
-    198, 330, 255, 267, 331, 340, 256, 268, 233, 694, 257, 269, 309, 320, 280, 331, 321,
-    335, 336, 230, 339, 333, 198, 333, 255, 267, 334, 340, 256, 268, 156, 286, 257, 269,
-    281, 282, 283, 310, 311, 249, 246, 246, 247, 246, 246, 246, 246, 246, 246, 246, 246,
-    246, 246, 246, 246, 246, 246, 246, 250, 250, 246, 246, 246, 246, 246, 250,
-
-    250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
-    246, 246, 246, 246, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
-    250, 250, 250, 250, 246, 246, 246, 246, 260, 259, 260, 208, 202, 208, 202, 345, 208,
-    213, 208, 213, 230, 689, 233, 247, 693, 346, 686, 233, 144, 234, 144, 351, 352, 144,
-    234, 144, 359, 345, 245, 209, 235, 312, 210, 313, 314, 235, 317, 346, 318, 230, 402,
-    692, 689, 351, 352, 680, 334, 678, 359, 403, 245, 209, 235, 312, 210, 313,
-
-    314, 235, 317, 341, 318, 261, 258, 258, 259, 258, 258, 258, 258, 258, 258, 258, 258,
-    258, 258, 258, 258, 258, 258, 258, 262, 262, 258, 258, 258, 258, 258, 262, 262, 262,
-    262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 258, 258,
-    258, 258, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, 262,
-    262, 262, 258, 258, 258, 258, 272, 271, 272, 219, 219, 230, 219, 230, 236, 230, 271,
-    271, 360, 237, 375, 238, 376, 378, 379, 393, 394, 687, 327, 405, 410, 411,
-
-    239, 414, 408, 415, 227, 328, 406, 228, 360, 402, 375, 409, 376, 378, 379, 393, 394,
-    236, 403, 686, 410, 411, 239, 414, 334, 415, 227, 337, 338, 228, 324, 322, 323, 357,
-    325, 432, 332, 273, 270, 270, 271, 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
-    270, 270, 270, 270, 270, 274, 274, 270, 270, 270, 270, 270, 274, 274, 274, 274, 274,
-    274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 270, 270, 270, 270,
-    274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274,
-
-    274, 274, 270, 270, 270, 270, 271, 247, 142, 159, 142, 159, 306, 191, 306, 191, 199,
-    199, 199, 201, 702, 702, 190, 190, 211, 211, 211, 212, 220, 219, 220, 231, 190, 231,
-    327, 247, 248, 247, 248, 259, 259, 230, 202, 328, 260, 259, 260, 420, 259, 684, 683,
-    247, 271, 272, 271, 272, 327, 306, 144, 306, 342, 343, 668, 680, 271, 328, 259, 190,
-    277, 420, 278, 143, 160, 219, 255, 247, 192, 307, 256, 200, 200, 380, 257, 702, 702,
-    347, 230, 160, 160, 267, 344, 221, 230, 268, 232, 350, 255, 269, 329, 249,
-
-    256, 348, 349, 247, 257, 354, 355, 261, 279, 271, 279, 267, 279, 271, 279, 268, 273,
-    354, 358, 269, 329, 396, 307, 202, 386, 247, 386, 202, 213, 213, 416, 413, 421, 387,
-    259, 412, 280, 247, 259, 144, 397, 219, 397, 144, 144, 144, 259, 259, 426, 398, 427,
-    418, 271, 271, 421, 271, 281, 282, 283, 382, 281, 282, 353, 383, 390, 391, 271, 271,
-    438, 438, 426, 219, 427, 388, 190, 190, 230, 678, 202, 389, 219, 382, 424, 417, 219,
-    383, 390, 391, 219, 399, 438, 438, 419, 422, 144, 400, 449, 447, 386, 402,
-
-    386, 213, 425, 430, 423, 213, 428, 387, 403, 247, 456, 429, 247, 405, 448, 433, 464,
-    144, 449, 405, 455, 144, 406, 230, 431, 397, 219, 397, 406, 408, 408, 247, 456, 459,
-    398, 259, 460, 247, 409, 409, 271, 259, 259, 259, 465, 483, 675, 271, 271, 271, 271,
-    271, 491, 219, 491, 190, 219, 219, 467, 230, 219, 492, 190, 461, 230, 247, 465, 468,
-    469, 466, 402, 247, 405, 473, 474, 408, 247, 478, 247, 403, 478, 406, 500, 462, 409,
-    259, 259, 470, 476, 468, 469, 472, 471, 480, 463, 473, 474, 475, 477, 478,
-
-    479, 484, 478, 498, 500, 509, 505, 506, 481, 507, 497, 514, 247, 514, 508, 259, 485,
-    504, 259, 271, 515, 520, 259, 520, 510, 271, 512, 271, 271, 271, 521, 531, 534, 513,
-    534, 511, 491, 190, 491, 500, 543, 535, 219, 219, 516, 492, 546, 531, 546, 230, 517,
-    553, 219, 553, 247, 547, 557, 247, 247, 259, 554, 500, 514, 247, 514, 518, 259, 259,
-    271, 377, 657, 515, 271, 519, 520, 259, 520, 481, 523, 271, 672, 271, 534, 521, 534,
-    559, 584, 526, 584, 522, 527, 535, 544, 555, 531, 585, 582, 566, 591, 531,
-
-    591, 531, 247, 543, 558, 594, 552, 559, 543, 546, 557, 546, 247, 563, 259, 597, 259,
-    597, 547, 566, 531, 562, 570, 569, 598, 576, 553, 219, 553, 557, 582, 577, 575, 271,
-    247, 554, 604, 219, 604, 608, 619, 584, 625, 584, 625, 605, 628, 631, 628, 582, 585,
-    626, 591, 531, 591, 259, 543, 609, 594, 671, 670, 638, 543, 592, 632, 582, 632, 247,
-    612, 613, 639, 597, 616, 597, 594, 259, 604, 219, 604, 582, 598, 582, 659, 271, 606,
-    605, 668, 646, 608, 641, 608, 594, 620, 647, 271, 647, 650, 625, 650, 625,
-
-    628, 673, 628, 673, 643, 651, 626, 638, 636, 638, 644, 629, 632, 582, 632, 663, 639,
-    592, 639, 647, 271, 647, 594, 665, 664, 660, 650, 638, 650, 633, 663, 666, 663, 377,
-    669, 651, 639, 663, 673, 664, 673, 664, 681, 271, 681, 640, 664, 681, 271, 681, 658,
-    657, 655, 654, 653, 652, 618, 646, 648, 615, 643, 611, 636, 603, 601, 629, 674, 634,
-    596, 630, 627, 624, 582, 661, 623, 622, 621, 633, 618, 574, 572, 615, 568, 565, 648,
-    611, 561, 603, 601, 551, 599, 596, 590, 589, 588, 587, 676, 586, 583, 582,
-
-    531, 578, 525, 674, 574, 572, 568, 682, 565, 561, 551, 549, 682, 144, 144, 162, 162,
-    162, 162, 162, 162, 165, 165, 165, 165, 165, 165, 183, 183, 189, 189, 548, 189, 189,
-    189, 202, 545, 202, 202, 203, 203, 203, 213, 541, 213, 213, 214, 214, 214, 218, 218,
-    218, 218, 218, 218, 229, 229, 540, 229, 229, 229, 246, 246, 246, 246, 246, 246, 258,
-    258, 258, 258, 258, 258, 270, 270, 270, 270, 270, 270, 326, 326, 326, 326, 326, 326,
-    401, 401, 401, 401, 401, 401, 404, 404, 404, 404, 404, 404, 407, 407, 407,
-
-    407, 407, 407, 457, 457, 457, 457, 457, 457, 524, 524, 524, 524, 524, 524, 530, 530,
-    530, 530, 530, 530, 542, 542, 542, 542, 542, 542, 550, 550, 550, 550, 550, 550, 556,
-    556, 556, 556, 556, 556, 560, 560, 560, 560, 560, 560, 564, 564, 564, 564, 564, 564,
-    567, 567, 567, 567, 567, 567, 571, 571, 571, 571, 571, 571, 573, 573, 573, 573, 573,
-    573, 581, 581, 581, 581, 581, 581, 593, 593, 593, 593, 593, 593, 595, 595, 595, 595,
-    595, 595, 600, 600, 600, 600, 600, 600, 602, 602, 602, 602, 602, 602, 607,
-
-    607, 607, 607, 607, 607, 610, 610, 610, 610, 610, 610, 614, 614, 614, 614, 614, 614,
-    617, 617, 617, 617, 617, 617, 635, 635, 635, 635, 635, 635, 637, 637, 637, 637, 637,
-    637, 642, 642, 642, 642, 642, 642, 645, 645, 645, 645, 645, 645, 656, 656, 656, 656,
-    656, 656, 662, 662, 662, 662, 662, 662, 667, 667, 667, 667, 667, 667, 677, 677, 677,
-    677, 677, 677, 679, 679, 679, 679, 679, 679, 685, 685, 685, 685, 685, 685, 688, 688,
-    688, 688, 688, 688, 539, 538, 537, 536, 533, 532, 531, 529, 528, 525, 458,
-
-    503, 502, 501, 499, 496, 495, 494, 493, 490, 489, 488, 487, 486, 485, 482, 447, 458,
-    454, 453, 452, 451, 450, 377, 446, 445, 444, 443, 442, 441, 440, 439, 437, 436, 435,
-    434, 392, 385, 384, 303, 303, 301, 301, 374, 373, 372, 371, 370, 369, 366, 365, 364,
-    363, 362, 361, 271, 271, 271, 259, 259, 259, 247, 247, 247, 230, 230, 230, 219, 219,
-    219, 319, 316, 190, 190, 190, 299, 166, 297, 296, 295, 294, 287, 702, 275, 271, 271,
-    263, 259, 259, 251, 247, 247, 241, 230, 230, 223, 219, 219, 194, 190, 190,
-
-    188, 186, 184, 182, 181, 180, 166, 164, 161, 145, 702, 23,  702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702};
-
-static yyconst flex_int16_t yy_chk[2581] = {
-    0,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
-    3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
-
-    3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
-    3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
-    3,   3,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,
-    5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,
-    5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,
-    5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,
-
-    5,   5,   5,   5,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-    7,   7,   7,   7,   9,   10,  9,   10,  30,  31,  36,  31,  42,  36,  43,  46,  47,
-    45,  48,  57,  48,  47,  42,  43,  45,  61,  46,  70,  79,  91,  30,  48,
-
-    82,  94,  82,  94,  102, 112, 95,  121, 130, 57,  139, 145, 79,  91,  698, 61,  46,
-    70,  95,  157, 157, 48,  162, 187, 187, 162, 102, 112, 95,  121, 130, 697, 139, 145,
-    695, 9,   10,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,
-    11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,
-    11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,
-    11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,  11,
-
-    11,  11,  11,  11,  11,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,
-    13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,
-    13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,
-    13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,
-    13,  13,  13,  13,  13,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,
-    15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,
-
-    15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,
-    15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,
-    15,  15,  15,  15,  15,  15,  15,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,
-    17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,
-    17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,
-    17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,
-
-    17,  17,  17,  17,  17,  17,  17,  17,  17,  19,  19,  19,  19,  19,  19,  19,  19,
-    19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,
-    19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,
-    19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,  19,
-    19,  19,  19,  19,  19,  19,  19,  19,  19,  21,  21,  21,  21,  21,  21,  21,  21,
-    21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,
-
-    21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,
-    21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,
-    21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  21,  25,  71,  25,  72,  33,  66,
-    33,  66,  74,  76,  74,  76,  78,  80,  81,  66,  84,  86,  84,  86,  88,  72,  88,
-    90,  158, 103, 92,  146, 158, 80,  81,  83,  93,  83,  97,  97,  97,  106, 694, 106,
-    693, 122, 92,  72,  131, 203, 113, 106, 93,  146, 692, 81,  80,  322, 71,
-
-    160, 71,  281, 104, 83,  152, 203, 83,  25,  32,  92,  32,  33,  66,  93,  311, 74,
-    76,  81,  620, 78,  114, 160, 152, 84,  86,  83,  152, 88,  83,  104, 90,  103, 104,
-    103, 32,  93,  32,  184, 114, 32,  32,  97,  32,  113, 106, 113, 281, 122, 32,  122,
-    131, 104, 131, 311, 104, 322, 32,  32,  32,  184, 114, 32,  32,  68,  68,  620, 68,
-    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
-    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
-
-    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
-    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  68,  100, 100,
-    100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
-    100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
-    100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
-    100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
-
-    108, 109, 151, 173, 214, 177, 109, 108, 109, 178, 174, 178, 174, 185, 173, 174, 177,
-    194, 108, 109, 214, 179, 178, 179, 209, 209, 179, 292, 307, 529, 151, 151, 691, 292,
-    529, 185, 173, 307, 177, 194, 108, 109, 110, 110, 178, 110, 110, 110, 110, 110, 110,
-    110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
-    110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
-    110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
-
-    110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 116, 116, 116, 123, 132, 149, 192,
-    149, 683, 330, 141, 141, 141, 683, 195, 223, 330, 198, 224, 241, 242, 235, 251, 235,
-    192, 235, 123, 132, 235, 252, 123, 132, 331, 690, 123, 132, 195, 223, 141, 331, 224,
-    241, 242, 239, 251, 239, 192, 239, 123, 132, 239, 252, 123, 132, 149, 149, 123, 132,
-    141, 141, 141, 198, 198, 116, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
-    119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
-
-    119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
-    119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
-    119, 119, 119, 119, 119, 119, 119, 119, 125, 125, 125, 200, 204, 200, 205, 263, 208,
-    215, 208, 216, 232, 688, 234, 255, 687, 264, 685, 237, 204, 234, 205, 275, 276, 215,
-    237, 216, 284, 263, 232, 200, 234, 204, 200, 205, 208, 237, 215, 264, 216, 333, 325,
-    684, 682, 275, 276, 679, 333, 677, 284, 325, 232, 200, 234, 204, 200, 205,
-
-    208, 237, 215, 255, 216, 125, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-    128, 128, 128, 128, 128, 128, 134, 134, 134, 221, 227, 230, 228, 236, 238, 245, 282,
-    357, 285, 238, 304, 238, 305, 308, 309, 320, 321, 675, 326, 329, 335, 336,
-
-    238, 339, 332, 340, 221, 326, 329, 221, 285, 401, 304, 332, 305, 308, 309, 320, 321,
-    334, 401, 674, 335, 336, 238, 339, 334, 340, 221, 245, 245, 221, 228, 227, 227, 282,
-    230, 357, 236, 134, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
-    137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
-    137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
-    137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
-
-    137, 137, 137, 137, 137, 137, 140, 256, 142, 159, 142, 159, 190, 191, 190, 191, 199,
-    201, 199, 201, 202, 213, 190, 191, 211, 212, 211, 212, 220, 220, 220, 231, 310, 231,
-    233, 257, 248, 248, 248, 267, 269, 231, 382, 233, 260, 260, 260, 345, 268, 672, 671,
-    249, 280, 272, 272, 272, 328, 306, 382, 306, 256, 256, 667, 666, 283, 328, 261, 306,
-    140, 345, 140, 142, 159, 323, 249, 341, 191, 190, 249, 199, 201, 310, 249, 202, 213,
-    267, 337, 211, 212, 261, 257, 220, 338, 261, 231, 269, 249, 261, 233, 248,
-
-    249, 268, 268, 343, 249, 280, 280, 260, 273, 273, 273, 261, 279, 279, 279, 261, 272,
-    283, 283, 261, 328, 323, 306, 312, 316, 342, 316, 313, 317, 318, 341, 338, 346, 316,
-    349, 337, 273, 344, 347, 312, 324, 324, 324, 313, 317, 318, 348, 350, 351, 324, 352,
-    343, 353, 354, 346, 355, 273, 273, 273, 312, 279, 279, 279, 313, 317, 318, 356, 358,
-    365, 374, 351, 395, 352, 316, 380, 381, 412, 665, 383, 316, 396, 312, 349, 342, 399,
-    313, 317, 318, 400, 324, 365, 374, 344, 347, 383, 324, 381, 374, 386, 403,
-
-    386, 390, 350, 355, 348, 391, 353, 386, 403, 417, 396, 354, 416, 404, 380, 358, 412,
-    390, 381, 406, 395, 391, 404, 413, 356, 397, 397, 397, 406, 407, 409, 419, 396, 399,
-    397, 422, 400, 418, 407, 409, 428, 425, 423, 424, 413, 436, 660, 430, 432, 429, 433,
-    431, 443, 455, 443, 448, 456, 459, 417, 464, 460, 443, 449, 403, 465, 466, 413, 418,
-    418, 416, 461, 467, 462, 424, 424, 463, 468, 430, 469, 461, 433, 462, 451, 406, 463,
-    471, 472, 419, 428, 418, 418, 423, 422, 432, 409, 424, 424, 425, 429, 430,
-
-    431, 436, 433, 449, 451, 465, 456, 459, 433, 460, 448, 470, 470, 470, 464, 473, 451,
-    455, 474, 476, 470, 475, 475, 475, 466, 477, 468, 480, 478, 481, 475, 497, 488, 469,
-    488, 467, 491, 498, 491, 499, 497, 488, 505, 507, 471, 491, 501, 508, 501, 509, 472,
-    506, 506, 506, 510, 501, 508, 512, 513, 518, 506, 499, 514, 514, 514, 473, 516, 519,
-    523, 659, 656, 514, 526, 474, 520, 520, 520, 476, 478, 527, 655, 576, 534, 520, 534,
-    510, 536, 480, 536, 477, 481, 534, 498, 507, 542, 536, 544, 516, 543, 543,
-
-    543, 556, 559, 542, 509, 544, 505, 510, 543, 546, 556, 546, 563, 513, 566, 548, 570,
-    548, 546, 516, 557, 512, 519, 518, 548, 526, 553, 553, 553, 557, 558, 527, 523, 577,
-    609, 553, 555, 555, 555, 558, 576, 584, 586, 584, 586, 555, 589, 592, 589, 593, 584,
-    586, 591, 591, 591, 613, 592, 559, 593, 654, 652, 606, 591, 543, 594, 594, 594, 641,
-    563, 566, 606, 597, 570, 597, 594, 644, 604, 604, 604, 607, 597, 608, 633, 649, 557,
-    604, 648, 645, 607, 609, 608, 633, 577, 619, 619, 619, 621, 625, 621, 625,
-
-    628, 658, 628, 658, 642, 621, 625, 637, 635, 639, 613, 589, 632, 632, 632, 640, 637,
-    591, 639, 647, 647, 647, 632, 641, 640, 634, 650, 661, 650, 594, 662, 644, 664, 631,
-    649, 650, 661, 676, 673, 662, 673, 664, 669, 669, 669, 608, 676, 681, 681, 681, 630,
-    629, 627, 624, 623, 622, 617, 616, 619, 614, 612, 610, 605, 602, 600, 628, 658, 599,
-    595, 590, 588, 583, 581, 639, 580, 579, 578, 632, 575, 573, 571, 569, 567, 564, 647,
-    562, 560, 554, 552, 550, 549, 545, 541, 540, 539, 538, 664, 537, 533, 532,
-
-    530, 528, 524, 673, 522, 521, 517, 669, 515, 511, 504, 503, 681, 703, 703, 704, 704,
-    704, 704, 704, 704, 705, 705, 705, 705, 705, 705, 706, 706, 707, 707, 502, 707, 707,
-    707, 708, 500, 708, 708, 709, 709, 709, 710, 496, 710, 710, 711, 711, 711, 712, 712,
-    712, 712, 712, 712, 713, 713, 495, 713, 713, 713, 714, 714, 714, 714, 714, 714, 715,
-    715, 715, 715, 715, 715, 716, 716, 716, 716, 716, 716, 717, 717, 717, 717, 717, 717,
-    718, 718, 718, 718, 718, 718, 719, 719, 719, 719, 719, 719, 720, 720, 720,
-
-    720, 720, 720, 721, 721, 721, 721, 721, 721, 722, 722, 722, 722, 722, 722, 723, 723,
-    723, 723, 723, 723, 724, 724, 724, 724, 724, 724, 725, 725, 725, 725, 725, 725, 726,
-    726, 726, 726, 726, 726, 727, 727, 727, 727, 727, 727, 728, 728, 728, 728, 728, 728,
-    729, 729, 729, 729, 729, 729, 730, 730, 730, 730, 730, 730, 731, 731, 731, 731, 731,
-    731, 732, 732, 732, 732, 732, 732, 733, 733, 733, 733, 733, 733, 734, 734, 734, 734,
-    734, 734, 735, 735, 735, 735, 735, 735, 736, 736, 736, 736, 736, 736, 737,
-
-    737, 737, 737, 737, 737, 738, 738, 738, 738, 738, 738, 739, 739, 739, 739, 739, 739,
-    740, 740, 740, 740, 740, 740, 741, 741, 741, 741, 741, 741, 742, 742, 742, 742, 742,
-    742, 743, 743, 743, 743, 743, 743, 744, 744, 744, 744, 744, 744, 745, 745, 745, 745,
-    745, 745, 746, 746, 746, 746, 746, 746, 747, 747, 747, 747, 747, 747, 748, 748, 748,
-    748, 748, 748, 749, 749, 749, 749, 749, 749, 750, 750, 750, 750, 750, 750, 751, 751,
-    751, 751, 751, 751, 494, 493, 490, 489, 487, 486, 485, 483, 482, 479, 457,
-
-    454, 453, 452, 450, 447, 446, 445, 444, 442, 441, 440, 439, 438, 437, 435, 434, 398,
-    392, 389, 388, 385, 384, 377, 373, 372, 371, 370, 369, 368, 367, 366, 364, 363, 362,
-    361, 319, 315, 314, 303, 302, 301, 300, 298, 297, 296, 295, 294, 293, 291, 290, 289,
-    288, 287, 286, 278, 277, 270, 266, 265, 258, 254, 253, 246, 244, 243, 229, 226, 225,
-    218, 217, 210, 197, 196, 189, 167, 165, 156, 155, 154, 153, 150, 143, 138, 136, 133,
-    129, 127, 124, 120, 118, 115, 111, 107, 105, 101, 99,  96,  69,  67,  65,
-
-    62,  60,  56,  53,  52,  51,  39,  38,  35,  29,  23,  702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702,
-    702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702, 702};
-
-static yyconst flex_int16_t yy_rule_linenum[102] = {
-    0,   134, 135, 136, 137, 141, 142, 143, 144, 145, 147, 148, 150, 159, 160, 187, 222,
-    246, 252, 273, 280, 291, 296, 310, 315, 322, 346, 353, 355, 368, 381, 406, 412, 417,
-    422, 427, 437, 445, 453, 462, 490, 511, 512, 513, 514, 516, 521, 544, 546, 548, 586,
-    587, 590, 592, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613,
-    614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630,
-    631, 632, 633, 634, 635, 636, 642, 648, 660, 662, 664, 680, 681, 691, 694, 695,
-
-    697};
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static yyconst flex_int16_t yy_accept[703] =
+    {   0,
+        0,    0,   52,   52,    0,    0,   41,   41,    0,    0,
+        2,    2,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,  103,  100,  100,  101,   98,   99,   99,   99,
+      100,   95,   52,   72,   87,  100,   69,  100,  100,   73,
+       74,   65,   63,   75,   64,   51,   68,   50,   77,   76,
+       79,   54,   80,   78,   53,   53,   53,   88,   89,   70,
+       95,  100,   92,   66,  100,  100,   98,   99,   99,   99,
+      100,   95,   44,   44,   45,   41,   44,   41,   41,   41,
+       41,   44,   44,  100,    3,    3,    4,    2,    3,    2,
+        2,    2,    2,    3,    3,  100,  100,   35,   98,   99,
+
+       99,   99,  100,   95,  100,  100,   98,  100,  100,   99,
+       99,   99,  100,   95,  100,  100,   19,   98,   99,   99,
+       99,  100,   95,  100,  100,   23,   98,   99,   99,   99,
+      100,   95,  100,  100,   27,   98,   99,   99,   99,  100,
+       95,    0,    0,   99,   99,   99,   93,   94,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,   52,    0,
+       84,    0,   90,   85,    0,   91,   71,   57,   61,   55,
+       62,   56,   51,    0,   67,   58,   51,   50,    0,   81,
+       83,   82,   53,   53,   53,   59,    0,   86,    0,    0,
+        0,    0,   99,   99,   99,   93,   94,    0,    0,    0,
+
+       41,   41,   41,   41,   41,   42,   43,    0,    0,    0,
+        0,    2,    2,    2,    2,    2,    0,    0,   35,    0,
+        0,   99,   99,   99,   93,   94,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,   99,
+       99,   99,   93,   94,    0,    0,   19,    0,    0,   99,
+       99,   99,   93,   94,    0,    0,    0,    0,   23,    0,
+        0,   99,   99,   99,   93,   94,    0,    0,    0,    0,
+       27,    0,    0,   99,   99,   99,   93,   94,    0,    0,
+        0,    0,    0,   99,   99,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,   60,    0,
+
+       51,    0,   50,   53,   53,    0,   49,   99,   99,    0,
+        0,   41,   41,    0,    0,    0,    2,    2,    0,   99,
+       99,    0,    0,    0,    0,    0,   13,    0,    0,    0,
+        0,    0,    0,    0,   99,   99,    0,    0,   99,   99,
+        0,    0,    0,    0,   99,   99,    0,    0,    0,    0,
+       99,   99,    0,    0,    0,    0,    0,    0,   96,   97,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   53,   53,   49,   96,   97,    0,
+        0,   41,   41,    0,    0,    0,   37,    0,    0,    2,
+        2,    0,   96,   97,    0,    0,    0,    0,    0,    0,
+
+        0,   15,    0,    0,   13,    0,    0,   14,    0,   96,
+       97,    0,    0,   96,   97,    0,    0,    0,    0,   96,
+       97,    0,    0,    0,    0,   96,   97,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,   33,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    6,    0,    0,    0,    0,    0,    0,
+        0,   12,    0,    0,    0,    0,    0,    0,    0,    0,
+
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   24,    0,    0,    0,    0,    0,
+       39,    0,    0,    0,   29,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,   36,    0,    0,    0,
+       35,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       19,    0,    0,    0,   17,    0,    0,   23,    0,    0,
+        0,   21,    0,   27,    0,    0,    0,    0,    0,    0,
+        0,   46,    0,    0,   30,    0,    8,    0,    0,    0,
+        0,   49,    0,    0,    0,   40,    0,   38,    0,    0,
+
+       31,    0,   32,    0,    0,    0,    0,    0,    0,    0,
+       19,    0,    0,    0,   23,    0,    0,   27,    0,    0,
+        0,    0,    0,    0,    0,   47,    0,    0,    0,    0,
+       39,    0,   49,    0,    0,   34,    0,   15,    0,    0,
+        0,    0,   16,    0,    0,   20,    0,    0,    0,    0,
+       48,    0,    7,    0,    0,    0,   25,    0,   46,    0,
+        0,    0,   15,    0,    0,    0,    0,   25,    0,    9,
+        0,    0,    0,    0,    0,    0,    0,   18,    0,   22,
+        0,    0,    0,    0,    0,   28,    0,    0,   26,    0,
+        0,    0,    0,    0,    0,    5,    0,    0,   10,    1,
+
+       11,    0
+    } ;
+
+static yyconst flex_int32_t yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    4,    5,    6,    1,    7,    8,    9,   10,   11,
+       12,   13,   14,   15,   16,   17,   18,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   20,   21,   22,
+       23,   24,   25,    1,   26,   27,   28,   29,   30,   31,
+       29,   32,   33,   29,   29,   34,   35,   36,   37,   29,
+       38,   39,   29,   40,   41,   42,   29,   43,   29,   29,
+       44,   45,   46,   47,   29,    1,   48,   49,   50,   51,
+
+       52,   53,   29,   54,   55,   29,   29,   56,   29,   57,
+       58,   59,   38,   60,   61,   62,   63,   29,   64,   43,
+       29,   29,   65,   66,   67,   68,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst flex_int32_t yy_meta[69] =
+    {   0,
+        1,    2,    3,    4,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    5,    6,
+        1,    1,    1,    1,    1,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    1,    1,    1,    1,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    2,    1,    1,    1
+    } ;
+
+static yyconst flex_int16_t yy_base[752] =
+    {   0,
+        0,    0,   68,    0,  136,    0,  204,    0,  271,  272,
+      337,    0,  405,    0,  473,    0,  541,    0,  609,    0,
+      677,    0, 2511, 2512,  744, 2512, 2512,    0, 2467,  236,
+      213,  808,  748, 2512, 2486,  276, 2512, 2499, 2497, 2512,
+     2512,  268,  269, 2512,  270,  265,  267,  270, 2512, 2512,
+     2483, 2482, 2481, 2512,    0, 2460,  247, 2512, 2512, 2479,
+      264, 2435, 2512, 2512, 2488,  749, 2487,  864, 2455,  255,
+      735,  737, 2512,  752, 2512,  753, 2512,  756,  293,  755,
+      756,  236,  775,  760, 2512,  761, 2512,  764, 2512,  767,
+      294,  768,  774,  237,  277, 2494,  778, 2512, 2493,  932,
+
+     2452,  264,  768,  801, 2482,  781, 2481,  989,  990, 1042,
+     2449,  265,  780,  810, 2488, 1109, 2512, 2487, 1174, 2446,
+      267,  784, 1111, 2485, 1241, 2512, 2484, 1306, 2443,  268,
+      787, 1112, 2482, 1373, 2512, 2481, 1438, 2440,  270, 1504,
+     1119, 1507, 2440,    0,  279,  740, 2512, 2512, 1114, 2426,
+      975,  771, 2422, 2442, 2448, 2425,  264,  717, 1508,  771,
+     2512,  320, 2512, 2512, 2466, 2512, 2452, 2512, 2512, 2512,
+     2512, 2512,  985,  997, 2512, 2512,  987,  993, 1008, 2512,
+     2512, 2512,    0,  806,  981, 2512,  268, 2512, 2462, 1511,
+     1512, 1105,    0,  985, 1092, 2461, 2460, 1116, 1515, 1244,
+
+     1516, 1519,  787, 1243, 1245, 2512, 2512, 1249,  969, 2418,
+     1523, 1524, 1520, 1001, 1248, 1250, 2440, 2466, 2512, 1527,
+     1375,    0, 1093, 1096, 2465, 2464, 1376, 1378, 2454, 1368,
+     1530, 1243, 1532, 1245, 1120, 1370, 1250, 1371, 1142,    0,
+     1097, 1098, 2453, 2452, 1372, 2460, 2512, 1535, 1549,    0,
+     1100, 1107, 2459, 2458, 1255, 1505, 1533, 2457, 2512, 1543,
+     1564,    0, 1217, 1227, 2456, 2455, 1537, 1546, 1538, 2454,
+     2512, 1552, 1607,    0, 1233, 1234, 2453, 2452, 1611, 1550,
+      800, 1382, 1562, 1231, 1347, 2397, 2396, 2420, 2390, 2399,
+     2414,  977, 2398, 2389, 2416, 2406, 2391, 2392, 2512, 2423,
+
+     2422, 2421, 2420, 1349, 1351, 1556, 1026, 1352, 1353, 1521,
+      804, 1620, 1624, 2382, 2376, 1623, 1625, 1626, 2397, 1354,
+     1355,  796, 1571, 1639, 1282, 1394, 2512, 1554, 1395, 1108,
+     1131, 1400, 1272, 1406, 1359, 1360, 1575, 1581, 1362, 1364,
+     1573, 1623, 1601, 1635, 1508, 1593, 1636, 1644, 1632, 1645,
+     1609, 1611, 1650, 1651, 1653, 1664, 1383, 1665,    0,    0,
+     2384, 2384, 2396, 2380, 1636, 2390, 2378, 2378, 2372, 2368,
+     2398, 2398, 2376, 1637,    0,    0, 2420,    0,    0, 1663,
+     1664, 1539, 1675, 2361, 2369, 1697, 2512, 2368, 2368, 1698,
+     1702, 2391,    0,    0, 1669, 1678, 1724, 2414, 1682, 1686,
+
+     1407, 2512, 1697, 1711, 2512, 1717, 1727, 2512, 1728,    0,
+        0, 1665, 1712,    0,    0, 1710, 1707, 1735, 1729,    0,
+        0, 1733, 1740, 1741, 1739,    0,    0, 1738, 1747, 1745,
+     1749, 1746, 1748, 2355, 2359, 1735, 2347, 2360, 2372, 2358,
+     2358, 2346, 1751, 2376, 2381, 2343, 2341, 1744, 1751, 2352,
+     1750, 2350, 2350, 2375, 1751, 1754, 2397, 2512, 1755, 1758,
+     1768, 1770, 1773, 1748, 1753, 1763, 1769, 1774, 1776, 1810,
+     1783, 1784, 1813, 1816, 1820, 1817, 1823, 1826, 2396, 1825,
+     1827, 2335, 2360, 2512, 2393, 2328, 2368, 1831, 2340, 2341,
+     1835, 2512, 2354, 2350, 2102, 2089, 1829, 1826, 1807, 2084,
+
+     1845, 2079, 2072, 2108, 1840, 1850, 1841, 1845, 1838, 1852,
+     2107, 1855, 1856, 1861, 2106, 1864, 2104, 1857, 1865, 1873,
+     2103, 2102, 1866, 2100, 2512, 1870, 1877, 2051,  999, 2098,
+     2512, 2097, 2072, 1881, 2512, 1885, 2046, 2029, 2062, 2032,
+     2031, 1892, 1897, 1894, 2089, 1908, 2512, 1914, 2058, 2087,
+     2512, 2086, 1925, 2085, 1935, 1899, 1918, 1928, 1900, 2084,
+     2512, 2083, 1910, 2081, 2512, 1912, 2080, 2512, 2079, 1914,
+     2078, 2512, 2077, 2512, 2076, 1879, 1931, 2025, 2045, 2063,
+     2070, 2512, 2038, 1940, 2512, 1941, 2512, 2036, 1945, 2020,
+     1951, 1945, 1947, 1963, 2066, 2512, 1970, 2512, 2033, 2062,
+
+     2512, 2061, 2512, 1975, 2060, 1959, 1977, 1979, 1932, 2059,
+     2512, 2058, 1953, 2057, 2512, 2055, 2054, 2512, 1992,  817,
+     1995, 2044, 1988, 2024, 1996, 2512, 2042, 1999, 2049, 1997,
+     2031, 2011, 1980, 2015, 2006, 2512, 2005, 2512, 2007, 2013,
+     1965, 2002, 2512, 1973, 1985, 2512, 2018, 1984, 1981, 2025,
+     2512, 1894, 2512, 1949, 1844, 1868, 2512, 2000, 1867, 1710,
+     2025, 2028, 2512, 2030, 1675, 1561, 1560, 2512, 2041, 2512,
+     1514, 1514, 2037, 1417, 1365, 2035, 1289, 2512, 1287, 2512,
+     2046, 1284, 1088, 1274, 1258, 2512, 1228, 1253, 2512, 1113,
+     1021,  729,  774,  772,  268, 2512,  265,  248, 2512, 2512,
+
+     2512, 2512, 2109, 2115, 2121, 2123, 2129, 2134, 2136, 2141,
+     2143, 2149, 2155, 2161, 2167, 2173, 2179, 2185, 2191, 2197,
+     2203, 2209, 2215, 2221, 2227, 2233, 2239, 2245, 2251, 2257,
+     2263, 2269, 2275, 2281, 2287, 2293, 2299, 2305, 2311, 2317,
+     2323, 2329, 2335, 2341, 2347, 2353, 2359, 2365, 2371, 2377,
+     2383
+    } ;
+
+static yyconst flex_int16_t yy_def[752] =
+    {   0,
+      702,    1,  702,    3,  702,    5,  702,    7,    1,    1,
+      702,   11,  702,   13,  702,   15,  702,   17,  702,   19,
+      702,   21,  702,  702,  702,  702,  702,  703,  703,  703,
+      702,  702,  702,  702,  702,  704,  702,  702,  705,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  706,  706,  706,  702,  702,  702,
+      702,  702,  702,  702,  707,  707,  707,  702,   68,   68,
+      707,  707,  702,  702,  702,  708,  702,  708,  709,  709,
+      709,  702,  702,  702,  702,  702,  702,  710,  702,  710,
+      711,  711,  711,  702,  702,  712,  712,  702,  712,  702,
+
+      100,  100,  712,  712,  713,  713,  713,  713,  713,  702,
+      110,  110,  713,  713,  714,  714,  702,  714,  702,  119,
+      119,  714,  714,  715,  715,  702,  715,  702,  128,  128,
+      715,  715,  716,  716,  702,  716,  702,  137,  137,  716,
+      716,  702,   32,  703,  703,  703,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  704,  702,  702,  705,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  706,  706,  706,  702,  702,  702,  707,  707,
+      707,  707,   68,   68,   68,  707,  707,  707,  702,  702,
+
+      708,  708,  709,  709,  709,  702,  702,  702,  702,  702,
+      702,  710,  710,  711,  711,  711,  702,  712,  702,  712,
+      712,  100,  100,  100,  712,  712,  712,  712,  713,  713,
+      713,  713,  717,  713,  713,  713,  713,  713,  713,  110,
+      110,  110,  713,  713,  713,  714,  702,  714,  714,  119,
+      119,  119,  714,  714,  714,  714,  714,  715,  702,  715,
+      715,  128,  128,  128,  715,  715,  715,  715,  715,  716,
+      702,  716,  716,  137,  137,  137,  716,  716,  716,  716,
+      716,  716,  716,  703,  703,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+
+      702,  702,  702,  706,  706,  707,  707,   68,   68,  707,
+      707,  709,  709,  702,  702,  702,  711,  711,  702,  100,
+      100,  712,  712,  712,  718,  717,  702,  717,  719,  713,
+      713,  720,  713,  713,  110,  110,  713,  713,  119,  119,
+      714,  714,  714,  714,  128,  128,  715,  715,  715,  715,
+      137,  137,  716,  716,  716,  716,  716,  716,  703,  703,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  706,  706,  702,   68,   68,  707,
+      707,  709,  709,  702,  702,  702,  702,  702,  702,  711,
+      711,  702,  100,  100,  712,  712,  712,  721,  712,  712,
+
+      718,  702,  718,  719,  702,  719,  720,  702,  720,  110,
+      110,  713,  713,  119,  119,  714,  714,  714,  714,  128,
+      128,  715,  715,  715,  715,  137,  137,  716,  716,  716,
+      716,  716,  716,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  707,  707,  702,
+      702,  702,  702,  702,  712,  712,  721,  702,  712,  712,
+      718,  719,  720,  713,  713,  714,  714,  714,  714,  714,
+      715,  715,  715,  715,  715,  716,  716,  716,  722,  716,
+      716,  702,  702,  702,  723,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  724,  707,  702,  702,
+
+      702,  702,  702,  725,  712,  712,  712,  726,  713,  714,
+      727,  714,  714,  714,  728,  715,  729,  715,  715,  715,
+      730,  731,  716,  722,  702,  716,  716,  702,  702,  723,
+      702,  732,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  724,  724,  733,  734,  702,  702,  702,  702,  725,
+      702,  735,  712,  736,  712,  726,  726,  737,  714,  727,
+      702,  738,  714,  728,  702,  715,  729,  702,  739,  715,
+      730,  702,  731,  702,  740,  716,  716,  702,  702,  702,
+      732,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      724,  724,  733,  733,  734,  702,  702,  702,  702,  735,
+
+      702,  736,  702,  712,  741,  742,  737,  737,  714,  738,
+      702,  743,  715,  739,  702,  744,  740,  702,  716,  716,
+      702,  702,  702,  702,  702,  702,  702,  702,  745,  702,
+      702,  733,  733,  702,  741,  702,  742,  702,  742,  746,
+      714,  743,  702,  715,  744,  702,  716,  747,  716,  702,
+      702,  702,  702,  702,  702,  745,  702,  702,  702,  702,
+      742,  746,  702,  746,  748,  749,  747,  702,  716,  702,
+      702,  702,  702,  750,  702,  746,  748,  702,  749,  702,
+      716,  751,  702,  702,  750,  702,  702,  751,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+
+      702,    0,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702
+    } ;
+
+static yyconst flex_int16_t yy_nxt[2581] =
+    {   0,
+       24,   25,   26,   25,   24,   24,   27,   24,   24,   24,
+       24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
+       24,   24,   24,   24,   24,   28,   28,   28,   28,   29,
+       28,   28,   28,   28,   28,   28,   28,   30,   28,   28,
+       28,   28,   28,   24,   31,   24,   24,   28,   28,   28,
+       28,   29,   28,   28,   28,   28,   28,   28,   28,   28,
+       28,   28,   28,   28,   32,   24,   24,   24,   24,   33,
+       34,   33,   35,   36,   27,   37,   38,   39,   40,   41,
+       42,   43,   44,   45,   46,   47,   48,   49,   50,   51,
+       52,   53,   54,   55,   55,   55,   55,   56,   55,   55,
+
+       55,   55,   55,   55,   55,   57,   55,   55,   55,   55,
+       55,   58,   31,   59,   60,   55,   55,   55,   55,   56,
+       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
+       55,   55,   61,   62,   63,   64,   65,   66,   26,   66,
+       65,   65,   67,   65,   65,   65,   65,   65,   65,   65,
+       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+       65,   68,   68,   68,   68,   69,   68,   68,   68,   68,
+       68,   68,   68,   70,   68,   68,   68,   68,   68,   65,
+       71,   65,   65,   68,   68,   68,   68,   69,   68,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+
+       72,   65,   65,   65,   73,   74,   75,   76,   73,   73,
+       77,   73,   73,   73,   73,   73,   73,   73,   73,   73,
+       73,   73,   78,   73,   73,   73,   73,   73,   73,   79,
+       79,   79,   79,   80,   79,   79,   79,   79,   79,   79,
+       79,   81,   79,   79,   79,   79,   79,   73,   82,   73,
+       73,   79,   79,   79,   79,   80,   79,   79,   79,   79,
+       79,   79,   79,   79,   79,   79,   79,   79,   83,   73,
+       73,   73,   84,   84,   84,   84,  146,  147,  163,  148,
+      167,  163,  169,  173,  175,  171,  177,  185,  178,  176,
+      168,  170,  172,  187,  174,  195,  202,  213,  146,  179,
+
+      206,  147,  207,  148,  224,  242,  187,  252,  264,  185,
+      276,  284,  144,  144,  701,  187,  174,  195,  217,  289,
+      298,  179,  163,  289,  290,  163,  224,  242,  187,  252,
+      264,  700,  276,  284,  699,   61,   61,   85,   86,   87,
+       88,   85,   85,   89,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   90,   85,   85,   85,   85,
+       85,   85,   91,   91,   91,   91,   92,   91,   91,   91,
+       91,   91,   91,   91,   93,   91,   91,   91,   91,   91,
+       85,   94,   85,   85,   91,   91,   91,   91,   92,   91,
+       91,   91,   91,   91,   91,   91,   91,   91,   91,   91,
+
+       91,   95,   85,   85,   85,   96,   97,   98,   97,   96,
+       96,   99,   96,   96,   96,   96,   96,   96,   96,   96,
+       96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
+      100,  100,  100,  100,  101,  100,  100,  100,  100,  100,
+      100,  100,  102,  100,  100,  100,  100,  100,   96,  103,
+       96,   96,  100,  100,  100,  100,  101,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  104,
+       96,   96,   96,  105,  106,   26,  106,  105,  105,  107,
+      105,  105,  105,  105,  105,  105,  105,  105,  105,  108,
+      105,  109,  105,  105,  105,  105,  105,  105,  110,  110,
+
+      110,  110,  111,  110,  110,  110,  110,  110,  110,  110,
+      112,  110,  110,  110,  110,  110,  105,  113,  105,  105,
+      110,  110,  110,  110,  111,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  114,  105,  105,
+      105,  115,  116,  117,  116,  115,  115,  118,  115,  115,
+      115,  115,  115,  115,  115,  115,  115,  115,  115,  115,
+      115,  115,  115,  115,  115,  115,  119,  119,  119,  119,
+      120,  119,  119,  119,  119,  119,  119,  119,  121,  119,
+      119,  119,  119,  119,  115,  122,  115,  115,  119,  119,
+      119,  119,  120,  119,  119,  119,  119,  119,  119,  119,
+
+      119,  119,  119,  119,  119,  123,  115,  115,  115,  124,
+      125,  126,  125,  124,  124,  127,  124,  124,  124,  124,
+      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
+      124,  124,  124,  124,  128,  128,  128,  128,  129,  128,
+      128,  128,  128,  128,  128,  128,  130,  128,  128,  128,
+      128,  128,  124,  131,  124,  124,  128,  128,  128,  128,
+      129,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  132,  124,  124,  124,  133,  134,  135,
+      134,  133,  133,  136,  133,  133,  133,  133,  133,  133,
+      133,  133,  133,  133,  133,  133,  133,  133,  133,  133,
+
+      133,  133,  137,  137,  137,  137,  138,  137,  137,  137,
+      137,  137,  137,  137,  139,  137,  137,  137,  137,  137,
+      133,  140,  133,  133,  137,  137,  137,  137,  138,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  141,  133,  133,  133,  142,  190,  142,  190,  159,
+      191,  159,  191,  199,  199,  199,  201,  702,  202,  202,
+      190,  211,  211,  211,  211,  211,  198,  212,  702,  292,
+      219,  213,  285,  293,  144,  144,  208,  213,  208,  220,
+      219,  220,  231,  698,  231,  697,  247,  144,  198,  259,
+      202,  230,  230,  144,  285,  696,  205,  204,  219,  196,
+
+      187,  197,  271,  219,  209,  291,  144,  210,  143,  149,
+      215,  149,  160,  192,  216,  190,  200,  200,  205,  271,
+      702,  230,  187,  292,  160,  160,  209,  293,  160,  210,
+      227,  702,  225,  228,  226,  150,  216,  151,  304,  245,
+      152,  153,  221,  154,  243,  232,  244,  356,  253,  155,
+      254,  265,  227,  266,  381,  228,  395,  150,  156,  157,
+      304,  245,  158,  153,  189,  189,  649,  189,  189,  189,
+      189,  189,  189,  189,  189,  190,  189,  189,  189,  189,
+      189,  189,  193,  193,  189,  189,  189,  189,  189,  193,
+      193,  193,  193,  193,  193,  193,  193,  193,  193,  193,
+
+      193,  193,  193,  193,  193,  193,  193,  189,  189,  189,
+      189,  193,  193,  193,  193,  193,  193,  193,  193,  193,
+      193,  193,  193,  193,  193,  193,  193,  193,  189,  189,
+      189,  189,  218,  218,  219,  218,  218,  218,  218,  218,
+      218,  218,  218,  218,  218,  218,  218,  218,  218,  218,
+      222,  222,  218,  218,  218,  218,  218,  222,  222,  222,
+      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
+      222,  222,  222,  222,  222,  218,  218,  218,  218,  222,
+      222,  222,  222,  222,  222,  222,  222,  222,  222,  222,
+      222,  222,  222,  222,  222,  222,  218,  218,  218,  218,
+
+      233,  236,  288,  173,  213,  173,  237,  234,  238,  177,
+      300,  178,  300,  305,  174,  301,  174,  308,  235,  239,
+      144,  302,  179,  302,  315,  290,  303,  367,  377,  579,
+      289,  290,  695,  368,  580,  305,  174,  190,  174,  308,
+      235,  239,  229,  229,  179,  229,  229,  229,  229,  229,
+      229,  229,  229,  230,  229,  229,  229,  229,  229,  229,
+      240,  240,  229,  229,  229,  229,  229,  240,  240,  240,
+      240,  240,  240,  240,  240,  240,  240,  240,  240,  240,
+      240,  240,  240,  240,  240,  229,  229,  229,  229,  240,
+      240,  240,  240,  240,  240,  240,  240,  240,  240,  240,
+
+      240,  240,  240,  240,  240,  240,  229,  229,  229,  229,
+      248,  247,  248,  247,  259,  149,  190,  149,  690,  230,
+      279,  271,  279,  691,  309,  320,  331,  190,  321,  335,
+      336,  230,  339,  330,  198,  330,  255,  267,  331,  340,
+      256,  268,  233,  694,  257,  269,  309,  320,  280,  331,
+      321,  335,  336,  230,  339,  333,  198,  333,  255,  267,
+      334,  340,  256,  268,  156,  286,  257,  269,  281,  282,
+      283,  310,  311,  249,  246,  246,  247,  246,  246,  246,
+      246,  246,  246,  246,  246,  246,  246,  246,  246,  246,
+      246,  246,  250,  250,  246,  246,  246,  246,  246,  250,
+
+      250,  250,  250,  250,  250,  250,  250,  250,  250,  250,
+      250,  250,  250,  250,  250,  250,  250,  246,  246,  246,
+      246,  250,  250,  250,  250,  250,  250,  250,  250,  250,
+      250,  250,  250,  250,  250,  250,  250,  250,  246,  246,
+      246,  246,  260,  259,  260,  208,  202,  208,  202,  345,
+      208,  213,  208,  213,  230,  689,  233,  247,  693,  346,
+      686,  233,  144,  234,  144,  351,  352,  144,  234,  144,
+      359,  345,  245,  209,  235,  312,  210,  313,  314,  235,
+      317,  346,  318,  230,  402,  692,  689,  351,  352,  680,
+      334,  678,  359,  403,  245,  209,  235,  312,  210,  313,
+
+      314,  235,  317,  341,  318,  261,  258,  258,  259,  258,
+      258,  258,  258,  258,  258,  258,  258,  258,  258,  258,
+      258,  258,  258,  258,  262,  262,  258,  258,  258,  258,
+      258,  262,  262,  262,  262,  262,  262,  262,  262,  262,
+      262,  262,  262,  262,  262,  262,  262,  262,  262,  258,
+      258,  258,  258,  262,  262,  262,  262,  262,  262,  262,
+      262,  262,  262,  262,  262,  262,  262,  262,  262,  262,
+      258,  258,  258,  258,  272,  271,  272,  219,  219,  230,
+      219,  230,  236,  230,  271,  271,  360,  237,  375,  238,
+      376,  378,  379,  393,  394,  687,  327,  405,  410,  411,
+
+      239,  414,  408,  415,  227,  328,  406,  228,  360,  402,
+      375,  409,  376,  378,  379,  393,  394,  236,  403,  686,
+      410,  411,  239,  414,  334,  415,  227,  337,  338,  228,
+      324,  322,  323,  357,  325,  432,  332,  273,  270,  270,
+      271,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  274,  274,  270,  270,
+      270,  270,  270,  274,  274,  274,  274,  274,  274,  274,
+      274,  274,  274,  274,  274,  274,  274,  274,  274,  274,
+      274,  270,  270,  270,  270,  274,  274,  274,  274,  274,
+      274,  274,  274,  274,  274,  274,  274,  274,  274,  274,
+
+      274,  274,  270,  270,  270,  270,  271,  247,  142,  159,
+      142,  159,  306,  191,  306,  191,  199,  199,  199,  201,
+      702,  702,  190,  190,  211,  211,  211,  212,  220,  219,
+      220,  231,  190,  231,  327,  247,  248,  247,  248,  259,
+      259,  230,  202,  328,  260,  259,  260,  420,  259,  684,
+      683,  247,  271,  272,  271,  272,  327,  306,  144,  306,
+      342,  343,  668,  680,  271,  328,  259,  190,  277,  420,
+      278,  143,  160,  219,  255,  247,  192,  307,  256,  200,
+      200,  380,  257,  702,  702,  347,  230,  160,  160,  267,
+      344,  221,  230,  268,  232,  350,  255,  269,  329,  249,
+
+      256,  348,  349,  247,  257,  354,  355,  261,  279,  271,
+      279,  267,  279,  271,  279,  268,  273,  354,  358,  269,
+      329,  396,  307,  202,  386,  247,  386,  202,  213,  213,
+      416,  413,  421,  387,  259,  412,  280,  247,  259,  144,
+      397,  219,  397,  144,  144,  144,  259,  259,  426,  398,
+      427,  418,  271,  271,  421,  271,  281,  282,  283,  382,
+      281,  282,  353,  383,  390,  391,  271,  271,  438,  438,
+      426,  219,  427,  388,  190,  190,  230,  678,  202,  389,
+      219,  382,  424,  417,  219,  383,  390,  391,  219,  399,
+      438,  438,  419,  422,  144,  400,  449,  447,  386,  402,
+
+      386,  213,  425,  430,  423,  213,  428,  387,  403,  247,
+      456,  429,  247,  405,  448,  433,  464,  144,  449,  405,
+      455,  144,  406,  230,  431,  397,  219,  397,  406,  408,
+      408,  247,  456,  459,  398,  259,  460,  247,  409,  409,
+      271,  259,  259,  259,  465,  483,  675,  271,  271,  271,
+      271,  271,  491,  219,  491,  190,  219,  219,  467,  230,
+      219,  492,  190,  461,  230,  247,  465,  468,  469,  466,
+      402,  247,  405,  473,  474,  408,  247,  478,  247,  403,
+      478,  406,  500,  462,  409,  259,  259,  470,  476,  468,
+      469,  472,  471,  480,  463,  473,  474,  475,  477,  478,
+
+      479,  484,  478,  498,  500,  509,  505,  506,  481,  507,
+      497,  514,  247,  514,  508,  259,  485,  504,  259,  271,
+      515,  520,  259,  520,  510,  271,  512,  271,  271,  271,
+      521,  531,  534,  513,  534,  511,  491,  190,  491,  500,
+      543,  535,  219,  219,  516,  492,  546,  531,  546,  230,
+      517,  553,  219,  553,  247,  547,  557,  247,  247,  259,
+      554,  500,  514,  247,  514,  518,  259,  259,  271,  377,
+      657,  515,  271,  519,  520,  259,  520,  481,  523,  271,
+      672,  271,  534,  521,  534,  559,  584,  526,  584,  522,
+      527,  535,  544,  555,  531,  585,  582,  566,  591,  531,
+
+      591,  531,  247,  543,  558,  594,  552,  559,  543,  546,
+      557,  546,  247,  563,  259,  597,  259,  597,  547,  566,
+      531,  562,  570,  569,  598,  576,  553,  219,  553,  557,
+      582,  577,  575,  271,  247,  554,  604,  219,  604,  608,
+      619,  584,  625,  584,  625,  605,  628,  631,  628,  582,
+      585,  626,  591,  531,  591,  259,  543,  609,  594,  671,
+      670,  638,  543,  592,  632,  582,  632,  247,  612,  613,
+      639,  597,  616,  597,  594,  259,  604,  219,  604,  582,
+      598,  582,  659,  271,  606,  605,  668,  646,  608,  641,
+      608,  594,  620,  647,  271,  647,  650,  625,  650,  625,
+
+      628,  673,  628,  673,  643,  651,  626,  638,  636,  638,
+      644,  629,  632,  582,  632,  663,  639,  592,  639,  647,
+      271,  647,  594,  665,  664,  660,  650,  638,  650,  633,
+      663,  666,  663,  377,  669,  651,  639,  663,  673,  664,
+      673,  664,  681,  271,  681,  640,  664,  681,  271,  681,
+      658,  657,  655,  654,  653,  652,  618,  646,  648,  615,
+      643,  611,  636,  603,  601,  629,  674,  634,  596,  630,
+      627,  624,  582,  661,  623,  622,  621,  633,  618,  574,
+      572,  615,  568,  565,  648,  611,  561,  603,  601,  551,
+      599,  596,  590,  589,  588,  587,  676,  586,  583,  582,
+
+      531,  578,  525,  674,  574,  572,  568,  682,  565,  561,
+      551,  549,  682,  144,  144,  162,  162,  162,  162,  162,
+      162,  165,  165,  165,  165,  165,  165,  183,  183,  189,
+      189,  548,  189,  189,  189,  202,  545,  202,  202,  203,
+      203,  203,  213,  541,  213,  213,  214,  214,  214,  218,
+      218,  218,  218,  218,  218,  229,  229,  540,  229,  229,
+      229,  246,  246,  246,  246,  246,  246,  258,  258,  258,
+      258,  258,  258,  270,  270,  270,  270,  270,  270,  326,
+      326,  326,  326,  326,  326,  401,  401,  401,  401,  401,
+      401,  404,  404,  404,  404,  404,  404,  407,  407,  407,
+
+      407,  407,  407,  457,  457,  457,  457,  457,  457,  524,
+      524,  524,  524,  524,  524,  530,  530,  530,  530,  530,
+      530,  542,  542,  542,  542,  542,  542,  550,  550,  550,
+      550,  550,  550,  556,  556,  556,  556,  556,  556,  560,
+      560,  560,  560,  560,  560,  564,  564,  564,  564,  564,
+      564,  567,  567,  567,  567,  567,  567,  571,  571,  571,
+      571,  571,  571,  573,  573,  573,  573,  573,  573,  581,
+      581,  581,  581,  581,  581,  593,  593,  593,  593,  593,
+      593,  595,  595,  595,  595,  595,  595,  600,  600,  600,
+      600,  600,  600,  602,  602,  602,  602,  602,  602,  607,
+
+      607,  607,  607,  607,  607,  610,  610,  610,  610,  610,
+      610,  614,  614,  614,  614,  614,  614,  617,  617,  617,
+      617,  617,  617,  635,  635,  635,  635,  635,  635,  637,
+      637,  637,  637,  637,  637,  642,  642,  642,  642,  642,
+      642,  645,  645,  645,  645,  645,  645,  656,  656,  656,
+      656,  656,  656,  662,  662,  662,  662,  662,  662,  667,
+      667,  667,  667,  667,  667,  677,  677,  677,  677,  677,
+      677,  679,  679,  679,  679,  679,  679,  685,  685,  685,
+      685,  685,  685,  688,  688,  688,  688,  688,  688,  539,
+      538,  537,  536,  533,  532,  531,  529,  528,  525,  458,
+
+      503,  502,  501,  499,  496,  495,  494,  493,  490,  489,
+      488,  487,  486,  485,  482,  447,  458,  454,  453,  452,
+      451,  450,  377,  446,  445,  444,  443,  442,  441,  440,
+      439,  437,  436,  435,  434,  392,  385,  384,  303,  303,
+      301,  301,  374,  373,  372,  371,  370,  369,  366,  365,
+      364,  363,  362,  361,  271,  271,  271,  259,  259,  259,
+      247,  247,  247,  230,  230,  230,  219,  219,  219,  319,
+      316,  190,  190,  190,  299,  166,  297,  296,  295,  294,
+      287,  702,  275,  271,  271,  263,  259,  259,  251,  247,
+      247,  241,  230,  230,  223,  219,  219,  194,  190,  190,
+
+      188,  186,  184,  182,  181,  180,  166,  164,  161,  145,
+      702,   23,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702
+    } ;
+
+static yyconst flex_int16_t yy_chk[2581] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+
+        5,    5,    5,    5,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    9,   10,    9,   10,   30,   31,   36,   31,
+       42,   36,   43,   46,   47,   45,   48,   57,   48,   47,
+       42,   43,   45,   61,   46,   70,   79,   91,   30,   48,
+
+       82,   94,   82,   94,  102,  112,   95,  121,  130,   57,
+      139,  145,   79,   91,  698,   61,   46,   70,   95,  157,
+      157,   48,  162,  187,  187,  162,  102,  112,   95,  121,
+      130,  697,  139,  145,  695,    9,   10,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+
+       11,   11,   11,   11,   11,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+       13,   13,   13,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   25,   71,   25,   72,   33,
+       66,   33,   66,   74,   76,   74,   76,   78,   80,   81,
+       66,   84,   86,   84,   86,   88,   72,   88,   90,  158,
+      103,   92,  146,  158,   80,   81,   83,   93,   83,   97,
+       97,   97,  106,  694,  106,  693,  122,   92,   72,  131,
+      203,  113,  106,   93,  146,  692,   81,   80,  322,   71,
+
+      160,   71,  281,  104,   83,  152,  203,   83,   25,   32,
+       92,   32,   33,   66,   93,  311,   74,   76,   81,  620,
+       78,  114,  160,  152,   84,   86,   83,  152,   88,   83,
+      104,   90,  103,  104,  103,   32,   93,   32,  184,  114,
+       32,   32,   97,   32,  113,  106,  113,  281,  122,   32,
+      122,  131,  104,  131,  311,  104,  322,   32,   32,   32,
+      184,  114,   32,   32,   68,   68,  620,   68,   68,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+       68,   68,  100,  100,  100,  100,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,  100,  100,  100,
+
+      108,  109,  151,  173,  214,  177,  109,  108,  109,  178,
+      174,  178,  174,  185,  173,  174,  177,  194,  108,  109,
+      214,  179,  178,  179,  209,  209,  179,  292,  307,  529,
+      151,  151,  691,  292,  529,  185,  173,  307,  177,  194,
+      108,  109,  110,  110,  178,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+
+      110,  110,  110,  110,  110,  110,  110,  110,  110,  110,
+      116,  116,  116,  123,  132,  149,  192,  149,  683,  330,
+      141,  141,  141,  683,  195,  223,  330,  198,  224,  241,
+      242,  235,  251,  235,  192,  235,  123,  132,  235,  252,
+      123,  132,  331,  690,  123,  132,  195,  223,  141,  331,
+      224,  241,  242,  239,  251,  239,  192,  239,  123,  132,
+      239,  252,  123,  132,  149,  149,  123,  132,  141,  141,
+      141,  198,  198,  116,  119,  119,  119,  119,  119,  119,
+      119,  119,  119,  119,  119,  119,  119,  119,  119,  119,
+      119,  119,  119,  119,  119,  119,  119,  119,  119,  119,
+
+      119,  119,  119,  119,  119,  119,  119,  119,  119,  119,
+      119,  119,  119,  119,  119,  119,  119,  119,  119,  119,
+      119,  119,  119,  119,  119,  119,  119,  119,  119,  119,
+      119,  119,  119,  119,  119,  119,  119,  119,  119,  119,
+      119,  119,  125,  125,  125,  200,  204,  200,  205,  263,
+      208,  215,  208,  216,  232,  688,  234,  255,  687,  264,
+      685,  237,  204,  234,  205,  275,  276,  215,  237,  216,
+      284,  263,  232,  200,  234,  204,  200,  205,  208,  237,
+      215,  264,  216,  333,  325,  684,  682,  275,  276,  679,
+      333,  677,  284,  325,  232,  200,  234,  204,  200,  205,
+
+      208,  237,  215,  255,  216,  125,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  134,  134,  134,  221,  227,  230,
+      228,  236,  238,  245,  282,  357,  285,  238,  304,  238,
+      305,  308,  309,  320,  321,  675,  326,  329,  335,  336,
+
+      238,  339,  332,  340,  221,  326,  329,  221,  285,  401,
+      304,  332,  305,  308,  309,  320,  321,  334,  401,  674,
+      335,  336,  238,  339,  334,  340,  221,  245,  245,  221,
+      228,  227,  227,  282,  230,  357,  236,  134,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+
+      137,  137,  137,  137,  137,  137,  140,  256,  142,  159,
+      142,  159,  190,  191,  190,  191,  199,  201,  199,  201,
+      202,  213,  190,  191,  211,  212,  211,  212,  220,  220,
+      220,  231,  310,  231,  233,  257,  248,  248,  248,  267,
+      269,  231,  382,  233,  260,  260,  260,  345,  268,  672,
+      671,  249,  280,  272,  272,  272,  328,  306,  382,  306,
+      256,  256,  667,  666,  283,  328,  261,  306,  140,  345,
+      140,  142,  159,  323,  249,  341,  191,  190,  249,  199,
+      201,  310,  249,  202,  213,  267,  337,  211,  212,  261,
+      257,  220,  338,  261,  231,  269,  249,  261,  233,  248,
+
+      249,  268,  268,  343,  249,  280,  280,  260,  273,  273,
+      273,  261,  279,  279,  279,  261,  272,  283,  283,  261,
+      328,  323,  306,  312,  316,  342,  316,  313,  317,  318,
+      341,  338,  346,  316,  349,  337,  273,  344,  347,  312,
+      324,  324,  324,  313,  317,  318,  348,  350,  351,  324,
+      352,  343,  353,  354,  346,  355,  273,  273,  273,  312,
+      279,  279,  279,  313,  317,  318,  356,  358,  365,  374,
+      351,  395,  352,  316,  380,  381,  412,  665,  383,  316,
+      396,  312,  349,  342,  399,  313,  317,  318,  400,  324,
+      365,  374,  344,  347,  383,  324,  381,  374,  386,  403,
+
+      386,  390,  350,  355,  348,  391,  353,  386,  403,  417,
+      396,  354,  416,  404,  380,  358,  412,  390,  381,  406,
+      395,  391,  404,  413,  356,  397,  397,  397,  406,  407,
+      409,  419,  396,  399,  397,  422,  400,  418,  407,  409,
+      428,  425,  423,  424,  413,  436,  660,  430,  432,  429,
+      433,  431,  443,  455,  443,  448,  456,  459,  417,  464,
+      460,  443,  449,  403,  465,  466,  413,  418,  418,  416,
+      461,  467,  462,  424,  424,  463,  468,  430,  469,  461,
+      433,  462,  451,  406,  463,  471,  472,  419,  428,  418,
+      418,  423,  422,  432,  409,  424,  424,  425,  429,  430,
+
+      431,  436,  433,  449,  451,  465,  456,  459,  433,  460,
+      448,  470,  470,  470,  464,  473,  451,  455,  474,  476,
+      470,  475,  475,  475,  466,  477,  468,  480,  478,  481,
+      475,  497,  488,  469,  488,  467,  491,  498,  491,  499,
+      497,  488,  505,  507,  471,  491,  501,  508,  501,  509,
+      472,  506,  506,  506,  510,  501,  508,  512,  513,  518,
+      506,  499,  514,  514,  514,  473,  516,  519,  523,  659,
+      656,  514,  526,  474,  520,  520,  520,  476,  478,  527,
+      655,  576,  534,  520,  534,  510,  536,  480,  536,  477,
+      481,  534,  498,  507,  542,  536,  544,  516,  543,  543,
+
+      543,  556,  559,  542,  509,  544,  505,  510,  543,  546,
+      556,  546,  563,  513,  566,  548,  570,  548,  546,  516,
+      557,  512,  519,  518,  548,  526,  553,  553,  553,  557,
+      558,  527,  523,  577,  609,  553,  555,  555,  555,  558,
+      576,  584,  586,  584,  586,  555,  589,  592,  589,  593,
+      584,  586,  591,  591,  591,  613,  592,  559,  593,  654,
+      652,  606,  591,  543,  594,  594,  594,  641,  563,  566,
+      606,  597,  570,  597,  594,  644,  604,  604,  604,  607,
+      597,  608,  633,  649,  557,  604,  648,  645,  607,  609,
+      608,  633,  577,  619,  619,  619,  621,  625,  621,  625,
+
+      628,  658,  628,  658,  642,  621,  625,  637,  635,  639,
+      613,  589,  632,  632,  632,  640,  637,  591,  639,  647,
+      647,  647,  632,  641,  640,  634,  650,  661,  650,  594,
+      662,  644,  664,  631,  649,  650,  661,  676,  673,  662,
+      673,  664,  669,  669,  669,  608,  676,  681,  681,  681,
+      630,  629,  627,  624,  623,  622,  617,  616,  619,  614,
+      612,  610,  605,  602,  600,  628,  658,  599,  595,  590,
+      588,  583,  581,  639,  580,  579,  578,  632,  575,  573,
+      571,  569,  567,  564,  647,  562,  560,  554,  552,  550,
+      549,  545,  541,  540,  539,  538,  664,  537,  533,  532,
+
+      530,  528,  524,  673,  522,  521,  517,  669,  515,  511,
+      504,  503,  681,  703,  703,  704,  704,  704,  704,  704,
+      704,  705,  705,  705,  705,  705,  705,  706,  706,  707,
+      707,  502,  707,  707,  707,  708,  500,  708,  708,  709,
+      709,  709,  710,  496,  710,  710,  711,  711,  711,  712,
+      712,  712,  712,  712,  712,  713,  713,  495,  713,  713,
+      713,  714,  714,  714,  714,  714,  714,  715,  715,  715,
+      715,  715,  715,  716,  716,  716,  716,  716,  716,  717,
+      717,  717,  717,  717,  717,  718,  718,  718,  718,  718,
+      718,  719,  719,  719,  719,  719,  719,  720,  720,  720,
+
+      720,  720,  720,  721,  721,  721,  721,  721,  721,  722,
+      722,  722,  722,  722,  722,  723,  723,  723,  723,  723,
+      723,  724,  724,  724,  724,  724,  724,  725,  725,  725,
+      725,  725,  725,  726,  726,  726,  726,  726,  726,  727,
+      727,  727,  727,  727,  727,  728,  728,  728,  728,  728,
+      728,  729,  729,  729,  729,  729,  729,  730,  730,  730,
+      730,  730,  730,  731,  731,  731,  731,  731,  731,  732,
+      732,  732,  732,  732,  732,  733,  733,  733,  733,  733,
+      733,  734,  734,  734,  734,  734,  734,  735,  735,  735,
+      735,  735,  735,  736,  736,  736,  736,  736,  736,  737,
+
+      737,  737,  737,  737,  737,  738,  738,  738,  738,  738,
+      738,  739,  739,  739,  739,  739,  739,  740,  740,  740,
+      740,  740,  740,  741,  741,  741,  741,  741,  741,  742,
+      742,  742,  742,  742,  742,  743,  743,  743,  743,  743,
+      743,  744,  744,  744,  744,  744,  744,  745,  745,  745,
+      745,  745,  745,  746,  746,  746,  746,  746,  746,  747,
+      747,  747,  747,  747,  747,  748,  748,  748,  748,  748,
+      748,  749,  749,  749,  749,  749,  749,  750,  750,  750,
+      750,  750,  750,  751,  751,  751,  751,  751,  751,  494,
+      493,  490,  489,  487,  486,  485,  483,  482,  479,  457,
+
+      454,  453,  452,  450,  447,  446,  445,  444,  442,  441,
+      440,  439,  438,  437,  435,  434,  398,  392,  389,  388,
+      385,  384,  377,  373,  372,  371,  370,  369,  368,  367,
+      366,  364,  363,  362,  361,  319,  315,  314,  303,  302,
+      301,  300,  298,  297,  296,  295,  294,  293,  291,  290,
+      289,  288,  287,  286,  278,  277,  270,  266,  265,  258,
+      254,  253,  246,  244,  243,  229,  226,  225,  218,  217,
+      210,  197,  196,  189,  167,  165,  156,  155,  154,  153,
+      150,  143,  138,  136,  133,  129,  127,  124,  120,  118,
+      115,  111,  107,  105,  101,   99,   96,   69,   67,   65,
+
+       62,   60,   56,   53,   52,   51,   39,   38,   35,   29,
+       23,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+      702,  702,  702,  702,  702,  702,  702,  702,  702,  702
+    } ;
+
+static yyconst flex_int16_t yy_rule_linenum[102] =
+    {   0,
+      131,  132,  133,  134,  138,  139,  140,  141,  142,  144,
+      145,  147,  156,  157,  184,  219,  243,  249,  270,  277,
+      288,  293,  307,  312,  319,  343,  354,  356,  370,  383,
+      408,  414,  419,  424,  429,  439,  447,  455,  464,  492,
+      513,  514,  515,  516,  518,  523,  548,  550,  552,  590,
+      591,  594,  596,  604,  605,  606,  607,  608,  609,  610,
+      611,  612,  613,  614,  615,  616,  617,  618,  619,  620,
+      621,  622,  623,  624,  625,  626,  627,  628,  629,  630,
+      631,  632,  633,  634,  635,  636,  637,  638,  639,  640,
+      646,  652,  664,  666,  668,  684,  685,  695,  698,  699,
+
+      701
+    } ;
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
@@ -1003,62 +1339,62 @@ static yyconst flex_int16_t yy_rule_linenum[102] = {
  *
  */
 
-#include <fcntl.h>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <stack>
 #include <stdio.h>
 #include <string.h>
+#include <fcntl.h>
 #include <unistd.h>
 
-#include "apr_getline_int.h"
 #include "apr_scanner.h"
-#include "apr_util.h"
 #include "aprepro.h"
+#include "apr_util.h"
+#include "apr_getline_int.h"
 
 #define YY_NO_UNISTD_H
 /* import the parser's token type into a local typedef */
-typedef SEAMS::Parser::token      token;
+typedef SEAMS::Parser::token token;
 typedef SEAMS::Parser::token_type token_type;
 
 /* By default yylex returns int, we use token_type. Unfortunately yyterminate
  * by default returns 0, which is not of token_type. */
 #define yyterminate() return token::END
 
-#define show(x) *(aprepro->infoStream) << "<" << x << ">" << std::flush;
-namespace SEAMS {
-  extern bool echo;
-  void        yyerror(const char *s);
-} // namespace SEAMS
+#define show(x)   *(aprepro->infoStream) << "<" << x << ">" << std::flush;
+ namespace SEAMS {
+   extern bool echo;
+   void yyerror(const char *s);
+ }
 
 int file_must_exist = 0; /* Global used by include/conditional include */
 
 /* Global variables used by the looping mechanism */
-int           loop_lvl = 0;
+int loop_lvl = 0;
 std::fstream *tmp_file;
-const char *  temp_f;
+const char  *temp_f;
 
-#if defined           __NVCC__
+#if defined __NVCC__
 #pragma diag_suppress code_is_unreachable
 #endif
 
 #define MAX_IF_NESTING 64
 
-int    if_state[MAX_IF_NESTING]    = {0};     // INITIAL
-bool   if_case_run[MAX_IF_NESTING] = {false}; /* Has any if or elseif condition executed */
-int    if_lvl                      = 0;
-int    if_skip_level               = 0;
-bool   suppress_nl                 = false;
-bool   switch_active               = false; // Are we in a switch
-bool   switch_case_run             = false; // has there been a case which matched condition run?
-bool   switch_skip_to_endcase      = false;
-double switch_condition            = 0.0; // Value specified in "switch(condition)"
+ int if_state[MAX_IF_NESTING] = {0}; // INITIAL
+ int if_case_run[MAX_IF_NESTING] = {false}; /* Has any if or elseif condition executed */
+ int if_lvl = 0;
+ int if_skip_level = 0;
+bool suppress_nl = false;
+ bool switch_active = false;   // Are we in a switch
+ bool switch_case_run = false; // has there been a case which matched condition run?
+ bool switch_skip_to_endcase = false;
+ double switch_condition = 0.0; // Value specified in "switch(condition)"
 
 // For substitution history
-size_t      curr_index = 0;
+size_t curr_index = 0;
 std::string history_string;
-size_t      hist_start = 0;
+size_t hist_start = 0;
 
 #define YY_USER_ACTION curr_index += yyleng;
 
@@ -1113,11 +1449,11 @@ size_t      hist_start = 0;
 /* %endif */
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy(char *, yyconst char *, int);
+static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen(yyconst char *);
+static int yy_flex_strlen (yyconst char * );
 #endif
 
 #ifndef YY_NO_INPUT
@@ -1142,7 +1478,7 @@ static int yy_flex_strlen(yyconst char *);
 /* %if-c-only Standard (non-C++) definition */
 /* %endif */
 /* %if-c++-only C++ definition */
-#define ECHO LexerOutput(yytext, yyleng)
+#define ECHO LexerOutput( yytext, yyleng )
 /* %endif */
 #endif
 
@@ -1150,12 +1486,12 @@ static int yy_flex_strlen(yyconst char *);
  * is returned in "result".
  */
 #ifndef YY_INPUT
-#define YY_INPUT(buf, result, max_size)                                                            \
-  /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */          \
-                                                                                                   \
-  /* %if-c++-only C++ definition \ */                                                              \
-  if ((result = LexerInput((char *)buf, max_size)) < 0)                                            \
-    YY_FATAL_ERROR("input in flex scanner failed");
+#define YY_INPUT(buf,result,max_size) \
+/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
+\
+/* %if-c++-only C++ definition \ */\
+	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" );
 /* %endif */
 
 #endif
@@ -1178,7 +1514,7 @@ static int yy_flex_strlen(yyconst char *);
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-#define YY_FATAL_ERROR(msg) LexerError(msg)
+#define YY_FATAL_ERROR(msg) LexerError( msg )
 /* %endif */
 #endif
 
@@ -1220,7 +1556,8 @@ static int yy_flex_strlen(yyconst char *);
 #endif
 
 /* %% [6.0] YY_RULE_SETUP definition goes here */
-#define YY_RULE_SETUP YY_USER_ACTION
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
 
 /* %not-for-header */
 
@@ -1228,1078 +1565,1089 @@ static int yy_flex_strlen(yyconst char *);
  */
 YY_DECL
 {
-  yy_state_type yy_current_state;
-  char *        yy_cp, *yy_bp;
-  int           yy_act;
-
-  /* %% [7.0] user's declarations go here */
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+    
+/* %% [7.0] user's declarations go here */
 
-  if (!(yy_init)) {
-    (yy_init) = 1;
+	if ( !(yy_init) )
+		{
+		(yy_init) = 1;
 
 #ifdef YY_USER_INIT
-    YY_USER_INIT;
+		YY_USER_INIT;
 #endif
 
-    if (!(yy_start))
-      (yy_start) = 1; /* first start state */
-
-    if (!yyin)
-      /* %if-c-only */
-      /* %endif */
-      /* %if-c++-only */
-      yyin = &std::cin;
-    /* %endif */
-
-    if (!yyout)
-      /* %if-c-only */
-      /* %endif */
-      /* %if-c++-only */
-      yyout = &std::cout;
-    /* %endif */
-
-    if (!YY_CURRENT_BUFFER) {
-      yyensure_buffer_stack();
-      YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE);
-    }
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
 
-    yy_load_buffer_state();
-  }
+		if ( ! yyin )
+/* %if-c-only */
+/* %endif */
+/* %if-c++-only */
+			yyin = & std::cin;
+/* %endif */
 
-  while (1) /* loops until end-of-file is reached */
-  {
-    /* %% [8.0] yymore()-related code goes here */
-    yy_cp = (yy_c_buf_p);
+		if ( ! yyout )
+/* %if-c-only */
+/* %endif */
+/* %if-c++-only */
+			yyout = & std::cout;
+/* %endif */
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+		}
+
+		yy_load_buffer_state(  );
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+/* %% [8.0] yymore()-related code goes here */
+		yy_cp = (yy_c_buf_p);
+
+		/* Support of yytext. */
+		*yy_cp = (yy_hold_char);
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+/* %% [9.0] code to set up and find next match goes here */
+		yy_current_state = (yy_start);
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				(yy_last_accepting_state) = yy_current_state;
+				(yy_last_accepting_cpos) = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 703 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 2512 );
+
+yy_find_action:
+/* %% [10.0] code to find the action number goes here */
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+/* %% [11.0] code for yylineno update goes here */
+
+do_action:	/* This label is used only to access EOF actions. */
+
+/* %% [12.0] debug code goes here */
+		if ( yy_flex_debug )
+			{
+			if ( yy_act == 0 )
+				std::cerr << "--scanner backing up\n";
+			else if ( yy_act < 102 )
+				std::cerr << "--accepting rule at line " << yy_rule_linenum[yy_act] <<
+				         "(\"" << yytext << "\")\n";
+			else if ( yy_act == 102 )
+				std::cerr << "--accepting default rule (\"" << yytext << "\")\n";
+			else if ( yy_act == 103 )
+				std::cerr << "--(end of buffer or a NUL)\n";
+			else
+				std::cerr << "--EOF (start condition " << YY_START << ")\n";
+			}
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+/* %% [13.0] actions go here */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = (yy_hold_char);
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+{ BEGIN(INITIAL);   }
+	YY_BREAK
+case 2:
+case 3:
+YY_RULE_SETUP
+{ if (echo) ECHO; }
+	YY_BREAK
+case 4:
+/* rule 4 can match eol */
+YY_RULE_SETUP
+{ if (echo) ECHO; aprepro.ap_file_list.top().lineno++;   }
+	YY_BREAK
+
+case 5:
+YY_RULE_SETUP
+{ BEGIN(VERBATIM);  }
+	YY_BREAK
+case 6:
+case 7:
+YY_RULE_SETUP
+{ echo = true;      }
+	YY_BREAK
+case 8:
+case 9:
+YY_RULE_SETUP
+{ echo = false;     }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+{ aprepro.stateImmutable = true;    }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+{ aprepro.stateImmutable = aprepro.ap_options.immutable; }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+{
+    BEGIN(GET_LOOP_VAR);
+    if (aprepro.ap_options.debugging)
+      std::cerr << "DEBUG LOOP - Found loop begin test " << yytext << " in file "
+                << aprepro.ap_file_list.top().name << "\n";
+  }
+	YY_BREAK
 
-    /* Support of yytext. */
-    *yy_cp = (yy_hold_char);
+case 13:
+/* rule 13 can match eol */
+case 14:
+/* rule 14 can match eol */
+YY_RULE_SETUP
+{
+    /* Loop control defined by integer */
+    char *pt = strchr(yytext, ')');
+    *pt = '\0';
+    sscanf (yytext, "%lf", &yylval->val);
 
-    /* yy_bp points to the position in yy_ch_buf of the start of
-     * the current run.
-     */
-    yy_bp = yy_cp;
-
-    /* %% [9.0] code to set up and find next match goes here */
-    yy_current_state = (yy_start);
-  yy_match:
-    do {
-      YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-      if (yy_accept[yy_current_state]) {
-        (yy_last_accepting_state) = yy_current_state;
-        (yy_last_accepting_cpos)  = yy_cp;
-      }
-      while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
-        yy_current_state = (int)yy_def[yy_current_state];
-        if (yy_current_state >= 703)
-          yy_c = yy_meta[(unsigned int)yy_c];
-      }
-      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
-      ++yy_cp;
-    } while (yy_base[yy_current_state] != 2512);
-
-  yy_find_action:
-    /* %% [10.0] code to find the action number goes here */
-    yy_act = yy_accept[yy_current_state];
-    if (yy_act == 0) { /* have to back up */
-      yy_cp            = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      yy_act           = yy_accept[yy_current_state];
+    if (yylval->val <= 0) {
+      BEGIN(LOOP_SKIP);
     }
+    else {/* Value defined and != 0. */
+      temp_f = get_temp_filename();
+      SEAMS::file_rec new_file(temp_f, 0, true, (int)yylval->val);
+      aprepro.ap_file_list.push(new_file);
 
-    YY_DO_BEFORE_ACTION;
-
-    /* %% [11.0] code for yylineno update goes here */
-
-  do_action: /* This label is used only to access EOF actions. */
+      if (aprepro.ap_options.debugging)
+        std::cerr << "DEBUG LOOP VAR = " << aprepro.ap_file_list.top().loop_count
+                  << " in file " << aprepro.ap_file_list.top().name
+                  << " at line " << aprepro.ap_file_list.top().lineno << "\n";
 
-    /* %% [12.0] debug code goes here */
-    if (yy_flex_debug) {
-      if (yy_act == 0)
-        std::cerr << "--scanner backing up\n";
-      else if (yy_act < 102)
-        std::cerr << "--accepting rule at line " << yy_rule_linenum[yy_act] << "(\"" << yytext
-                  << "\")\n";
-      else if (yy_act == 102)
-        std::cerr << "--accepting default rule (\"" << yytext << "\")\n";
-      else if (yy_act == 103)
-        std::cerr << "--(end of buffer or a NUL)\n";
-      else
-        std::cerr << "--EOF (start condition " << YY_START << ")\n";
+      tmp_file = new std::fstream(temp_f, std::ios::out);
+      loop_lvl++;
+      BEGIN(LOOP);
     }
+    aprepro.ap_file_list.top().lineno++;
+    aprepro.isCollectingLoop = true;
+  }
+	YY_BREAK
+case 15:
+/* rule 15 can match eol */
+YY_RULE_SETUP
+{
+    /* Loop control defined by variable */
+    symrec *s;
+    char *pt = strchr(yytext, ')');
+    *pt = '\0';
+    if (!check_valid_var(yytext)) {
+      aprepro.warning("Invalid variable name syntax '" + std::string(yytext) + "'");
+      BEGIN(LOOP_SKIP);
+    } else {
+      s = aprepro.getsym(yytext);
+
+      if (s == nullptr || (s->type != token::SVAR && s->type != token::IMMSVAR && s->value.var == 0.)) {
+        BEGIN(LOOP_SKIP);
+      }
+      else { /* Value defined and != 0. */
+        temp_f = get_temp_filename();
+        SEAMS::file_rec new_file(temp_f, 0, true, (int)s->value.var);
+        aprepro.ap_file_list.push(new_file);
 
-    switch (yy_act) { /* beginning of action switch */
-                      /* %% [13.0] actions go here */
-    case 0:           /* must back up */
-      /* undo the effects of YY_DO_BEFORE_ACTION */
-      *yy_cp           = (yy_hold_char);
-      yy_cp            = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      goto yy_find_action;
-
-    case 1:
-      YY_RULE_SETUP { BEGIN(INITIAL); }
-      YY_BREAK
-    case 2:
-    case 3:
-      YY_RULE_SETUP
-      {
-        if (echo)
-          ECHO;
-      }
-      YY_BREAK
-    case 4:
-      /* rule 4 can match eol */
-      YY_RULE_SETUP
-      {
-        if (echo)
-          ECHO;
-        aprepro.ap_file_list.top().lineno++;
-      }
-      YY_BREAK
-
-    case 5:
-      YY_RULE_SETUP { BEGIN(VERBATIM); }
-      YY_BREAK
-    case 6:
-    case 7:
-      YY_RULE_SETUP { echo = true; }
-      YY_BREAK
-    case 8:
-    case 9:
-      YY_RULE_SETUP { echo = false; }
-      YY_BREAK
-    case 10:
-      YY_RULE_SETUP { aprepro.stateImmutable = true; }
-      YY_BREAK
-    case 11:
-      YY_RULE_SETUP { aprepro.stateImmutable = aprepro.ap_options.immutable; }
-      YY_BREAK
-    case 12:
-      YY_RULE_SETUP
-      {
-        BEGIN(GET_LOOP_VAR);
         if (aprepro.ap_options.debugging)
-          std::cerr << "DEBUG LOOP - Found loop begin test " << yytext << " in file "
-                    << aprepro.ap_file_list.top().name << "\n";
-      }
-      YY_BREAK
-
-    case 13:
-    /* rule 13 can match eol */
-    case 14:
-      /* rule 14 can match eol */
-      YY_RULE_SETUP
-      {
-        /* Loop control defined by integer */
-        char *pt = strchr(yytext, ')');
-        *pt      = '\0';
-        sscanf(yytext, "%lf", &yylval->val);
-
-        if (yylval->val <= 0) {
-          BEGIN(LOOP_SKIP);
-        }
-        else { /* Value defined and != 0. */
-          temp_f = get_temp_filename();
-          SEAMS::file_rec new_file(temp_f, 0, true, (int)yylval->val);
-          aprepro.ap_file_list.push(new_file);
-
-          if (aprepro.ap_options.debugging)
-            std::cerr << "DEBUG LOOP VAR = " << aprepro.ap_file_list.top().loop_count << " in file "
-                      << aprepro.ap_file_list.top().name << " at line "
-                      << aprepro.ap_file_list.top().lineno << "\n";
-
-          tmp_file = new std::fstream(temp_f, std::ios::out);
-          loop_lvl++;
-          BEGIN(LOOP);
-        }
-        aprepro.ap_file_list.top().lineno++;
-        aprepro.isCollectingLoop = true;
-      }
-      YY_BREAK
-    case 15:
-      /* rule 15 can match eol */
-      YY_RULE_SETUP
-      {
-        /* Loop control defined by variable */
-        symrec *s;
-        char *  pt = strchr(yytext, ')');
-        *pt        = '\0';
-        if (!check_valid_var(yytext)) {
-          aprepro.warning("Invalid variable name syntax '" + std::string(yytext) + "'");
-          BEGIN(LOOP_SKIP);
-        }
-        else {
-          s = aprepro.getsym(yytext);
+          std::cerr << "DEBUG LOOP VAR = " << aprepro.ap_file_list.top().loop_count
+                    << " in file " << aprepro.ap_file_list.top().name
+                    << " at line " << aprepro.ap_file_list.top().lineno << "\n";
 
-          if (s == nullptr ||
-              (s->type != token::SVAR && s->type != token::IMMSVAR && s->value.var == 0.)) {
-            BEGIN(LOOP_SKIP);
-          }
-          else { /* Value defined and != 0. */
-            temp_f = get_temp_filename();
-            SEAMS::file_rec new_file(temp_f, 0, true, (int)s->value.var);
-            aprepro.ap_file_list.push(new_file);
-
-            if (aprepro.ap_options.debugging)
-              std::cerr << "DEBUG LOOP VAR = " << aprepro.ap_file_list.top().loop_count
-                        << " in file " << aprepro.ap_file_list.top().name << " at line "
-                        << aprepro.ap_file_list.top().lineno << "\n";
-
-            tmp_file = new std::fstream(temp_f, std::ios::out);
-            loop_lvl++;
-            BEGIN(LOOP);
-          }
-        }
-        aprepro.ap_file_list.top().lineno++;
-        aprepro.isCollectingLoop = true;
+        tmp_file = new std::fstream(temp_f, std::ios::out);
+        loop_lvl++;
+        BEGIN(LOOP);
       }
-      YY_BREAK
+    }
+    aprepro.ap_file_list.top().lineno++;
+    aprepro.isCollectingLoop = true;
+  }
+	YY_BREAK
 
-    case 16:
-      /* rule 16 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if (loop_lvl > 0)
-          --loop_lvl;
+case 16:
+/* rule 16 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+    if(loop_lvl > 0)
+      --loop_lvl;
 
-        if (loop_lvl == 0) {
-          BEGIN(INITIAL);
-          tmp_file->close();
-          delete tmp_file;
+    if (loop_lvl == 0) {
+      BEGIN(INITIAL);
+      tmp_file->close();
+      delete tmp_file;
 
-          if (!aprepro.doLoopSubstitution)
-            yy_push_state(VERBATIM);
+      if(!aprepro.doLoopSubstitution)
+        yy_push_state(VERBATIM);
 
-          aprepro.isCollectingLoop = false;
+      aprepro.isCollectingLoop = false;
 
-          yyin = aprepro.open_file(aprepro.ap_file_list.top().name, "r");
-          yyFlexLexer::yypush_buffer_state(yyFlexLexer::yy_create_buffer(yyin, YY_BUF_SIZE));
-          curr_index = 0;
-        }
-        else {
-          (*tmp_file) << yytext;
-        }
-      }
-      YY_BREAK
-    case 17:
-      /* rule 17 can match eol */
-      YY_RULE_SETUP
-      {
-        loop_lvl++; /* Nested Loop */
-        (*tmp_file) << yytext;
-        aprepro.ap_file_list.top().lineno++;
-      }
-      YY_BREAK
-    case 18:
-      /* rule 18 can match eol */
-      YY_RULE_SETUP
-      {
-        if (aprepro.ap_options.interactive || aprepro.string_interactive()) {
-          aprepro.warning("Aborting loop(s).", false);
-
-          // Leave the looping state and remove the loop file
-          BEGIN(INITIAL);
-          tmp_file->close();
-          delete tmp_file;
-
-          if (aprepro.ap_file_list.top().tmp_file) {
-            remove(aprepro.ap_file_list.top().name.c_str());
-            aprepro.ap_file_list.pop();
-          }
-
-          loop_lvl                 = 0;
-          aprepro.isCollectingLoop = false;
-        }
-      }
-      YY_BREAK
-    case 19:
-      /* rule 19 can match eol */
-      YY_RULE_SETUP
-      {
-        (*tmp_file) << yytext;
-        aprepro.ap_file_list.top().lineno++;
-      }
-      YY_BREAK
-
-    case 20:
-      /* rule 20 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if (loop_lvl > 0)
-          --loop_lvl;
-
-        if (loop_lvl == 0) {
-          BEGIN(INITIAL);
-          aprepro.isCollectingLoop = false;
-        }
-      }
-      YY_BREAK
-    case 21:
-      /* rule 21 can match eol */
-      YY_RULE_SETUP
-      {
-        loop_lvl++; /* Nested Loop */
-        aprepro.ap_file_list.top().lineno++;
-      }
-      YY_BREAK
-    case 22:
-      /* rule 22 can match eol */
-      YY_RULE_SETUP
-      {
-        if (aprepro.ap_options.interactive || aprepro.string_interactive()) {
-          aprepro.warning("Aborting loops(s).", false);
-
-          // Leave the looping state
-          BEGIN(INITIAL);
-
-          loop_lvl                 = 0;
-          aprepro.isCollectingLoop = false;
-        }
-      }
-      YY_BREAK
-    case 23:
-      /* rule 23 can match eol */
-      YY_RULE_SETUP { aprepro.ap_file_list.top().lineno++; }
-      YY_BREAK
-
-    case 24:
-      /* rule 24 can match eol */
-      YY_RULE_SETUP
-      {
-        yyless(0);
-        curr_index = 0;
-        BEGIN(INITIAL);
-        switch_skip_to_endcase = false;
-      }
-      YY_BREAK
-    case 25:
-      /* rule 25 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if (!switch_active) {
-          yyerror("default statement found outside switch statement.");
-        }
+      yyin = aprepro.open_file(aprepro.ap_file_list.top().name, "r");
+      yyFlexLexer::yypush_buffer_state (yyFlexLexer::yy_create_buffer( yyin, YY_BUF_SIZE));
+      curr_index = 0;
+    }
+    else {
+      (*tmp_file) << yytext;
+    }
+  }
+	YY_BREAK
+case 17:
+/* rule 17 can match eol */
+YY_RULE_SETUP
+{
+    loop_lvl++; /* Nested Loop */
+    (*tmp_file) << yytext;
+    aprepro.ap_file_list.top().lineno++;
+  }
+	YY_BREAK
+case 18:
+/* rule 18 can match eol */
+YY_RULE_SETUP
+{
+    if(aprepro.ap_options.interactive ||
+       aprepro.string_interactive())
+    {
+      aprepro.warning("Aborting loop(s).", false);
 
-        if (!switch_case_run) {
-          switch_case_run = true;
-          BEGIN(INITIAL);
-          switch_skip_to_endcase = false;
-          if (aprepro.ap_options.debugging)
-            fprintf(stderr, "DEBUG SWITCH: 'default' code executing at line %d\n",
-                    aprepro.ap_file_list.top().lineno);
-        }
-        else {
-          if (aprepro.ap_options.debugging)
-            fprintf(stderr,
-                    "DEBUG SWITCH: 'default' not executing since a previous case already ran at "
-                    "line %d\n",
-                    aprepro.ap_file_list.top().lineno);
-
-          /* Need to skip all code until end of case */
-          BEGIN(END_CASE_SKIP);
-        }
-      }
-      YY_BREAK
-    case 26:
-      /* rule 26 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        BEGIN(INITIAL);
-        switch_active          = false;
-        switch_skip_to_endcase = false;
-      }
-      YY_BREAK
-    case 27:
-      /* rule 27 can match eol */
-      YY_RULE_SETUP { aprepro.ap_file_list.top().lineno++; }
-      YY_BREAK
-    case 28:
-      /* rule 28 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if (!switch_active) {
-          yyerror("endswitch statement found without matching switch.");
-        }
-        switch_active = false;
-      }
-      YY_BREAK
+      // Leave the looping state and remove the loop file
+      BEGIN(INITIAL);
+      tmp_file->close();
+      delete tmp_file;
 
-    /* This restores the old behavior of ifdef and ifndef
-     * where they would eat up any leading whitespace on
-     * a line.
-     */
-    case 29:
-      YY_RULE_SETUP
-      {
-        // Used to avoid undefined variable warnings in old ifdef/ifndef construct
-        aprepro.inIfdefGetvar = true;
-        unput('(');
-        unput('f');
-        unput('e');
-        unput('d');
-        unput('f');
-        unput('i');
-        unput('_');
-        unput('{');
-      }
-      YY_BREAK
-    case 30:
-      YY_RULE_SETUP
-      {
-        // Used to avoid undefined variable warnings in old ifdef/ifndef construct
-        aprepro.inIfdefGetvar = true;
-        unput('(');
-        unput('f');
-        unput('e');
-        unput('d');
-        unput('n');
-        unput('f');
-        unput('i');
-        unput('_');
-        unput('{');
-      }
-      YY_BREAK
-
-    /* If an if was found while skipping, then eat
-     * that entire if block until endif
-     * found since there is no way that
-     * any of the code in that if block could be executed.
-     * Make sure to handle multiple levels of skipped ifs...
-     *
-     * NOTE: if_lvl was not incremented, so don't need to decrement when
-     *       endif found.
-     */
-    case 31:
-      /* rule 31 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if (--if_skip_level == 0)
-          BEGIN(IF_SKIP);
-      }
-      YY_BREAK
-    case 32:
-      /* rule 32 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if_skip_level++;
-      }
-      YY_BREAK
-    case 33:
-      /* rule 33 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if_skip_level++;
-      }
-      YY_BREAK
-    case 34:
-      /* rule 34 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if_skip_level++;
-      }
-      YY_BREAK
-    case 35:
-      /* rule 35 can match eol */
-      YY_RULE_SETUP { aprepro.ap_file_list.top().lineno++; }
-      YY_BREAK
-
-    /* IF an if, ifdef, or ifndef found while skipping, then
-     * skip the entire block up and including the endif.
-     * The (IF_WHILE_SKIP) start condition handles this skipping.
-     */
-    case 36:
-      YY_RULE_SETUP
-      {
-        if (aprepro.ap_options.debugging)
-          fprintf(stderr, "DEBUG IF: 'ifdef'  found while skipping at line %d\n",
-                  aprepro.ap_file_list.top().lineno);
-        if_skip_level = 1;
-        BEGIN(IF_WHILE_SKIP);
-      }
-      YY_BREAK
-    case 37:
-      YY_RULE_SETUP
-      {
-        if (aprepro.ap_options.debugging)
-          fprintf(stderr, "DEBUG IF: 'ifdef'  found while skipping at line %d\n",
-                  aprepro.ap_file_list.top().lineno);
-        if_skip_level = 1;
-        BEGIN(IF_WHILE_SKIP);
-      }
-      YY_BREAK
-    case 38:
-      YY_RULE_SETUP
-      {
-        if (aprepro.ap_options.debugging)
-          fprintf(stderr, "DEBUG IF: 'ifndef'  found while skipping at line %d\n",
-                  aprepro.ap_file_list.top().lineno);
-        if_skip_level = 1;
-        BEGIN(IF_WHILE_SKIP);
+      if(aprepro.ap_file_list.top().tmp_file) {
+        remove(aprepro.ap_file_list.top().name.c_str());
+        aprepro.ap_file_list.pop();
       }
-      YY_BREAK
 
-    case 39:
-      /* rule 39 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-        if (aprepro.ap_options.debugging)
-          fprintf(stderr, "DEBUG IF: 'else'   at level = %d at line %d\n", if_lvl,
-                  aprepro.ap_file_list.top().lineno);
-        if (YY_START == VERBATIM) {
-          if (echo)
-            ECHO;
-        }
-        else if (if_state[if_lvl] == IF_SKIP) {
-          if (!if_case_run[if_lvl]) {
-            BEGIN(INITIAL);
-            if_state[if_lvl]    = INITIAL;
-            if_case_run[if_lvl] = true;
-          }
-          else {
-            BEGIN(IF_SKIP);
-            if_state[if_lvl] = IF_SKIP;
-          }
-        }
-        else if (if_state[if_lvl] == INITIAL) {
-          BEGIN(IF_SKIP);
-          if_state[if_lvl] = IF_SKIP;
-        }
+      loop_lvl = 0;
+      aprepro.isCollectingLoop = false;
+    }
+  }
+	YY_BREAK
+case 19:
+/* rule 19 can match eol */
+YY_RULE_SETUP
+{
+    (*tmp_file) << yytext;
+    aprepro.ap_file_list.top().lineno++;
+  }
+	YY_BREAK
 
-        /* If neither is true, this is a nested
-           if that should be skipped */
-      }
-      YY_BREAK
-
-    case 40:
-      /* rule 40 can match eol */
-      YY_RULE_SETUP
-      {
-        /* If any previous 'block' of this if has executed, then
-         * just skip this block; otherwise see if condition is
-         * true and execute this block
-         */
-        if (aprepro.ap_options.debugging)
-          fprintf(stderr, "DEBUG IF: 'elseif'   at level = %d at line %d\n", if_lvl,
-                  aprepro.ap_file_list.top().lineno);
+case 20:
+/* rule 20 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+    if(loop_lvl > 0)
+      --loop_lvl;
 
-        if (if_case_run[if_lvl]) { /* A previous else/elseif has run */
-          aprepro.ap_file_list.top().lineno++;
-          /* Already in IF_SKIP, so don't need to change state */
-        }
-        else {
-          /* Need to check the elseif condition; push back and parse */
-          yyless(0);
-          curr_index = 0;
-          BEGIN(INITIAL);
-          if_state[if_lvl] = INITIAL;
-        }
-      }
-      YY_BREAK
-    case 41:
-    case 42:
-    case 43:
-    case 44:
-      YY_RULE_SETUP { ; }
-      YY_BREAK
-    case 45:
-      /* rule 45 can match eol */
-      YY_RULE_SETUP { aprepro.ap_file_list.top().lineno++; }
-      YY_BREAK
-
-    case 46:
-      /* rule 46 can match eol */
-      YY_RULE_SETUP
-      {
-        aprepro.ap_file_list.top().lineno++;
-
-        if (YY_START == VERBATIM) {
-          if (echo)
-            ECHO;
-        }
-        else {
-          if (if_state[if_lvl] == IF_SKIP || if_state[if_lvl] == INITIAL)
-            BEGIN(INITIAL);
-          /* If neither is true, this is a nested
-             if that should be skipped */
-          if (aprepro.ap_options.debugging)
-            printf("DEBUG IF: 'endif'  at level = %d at line %d\n", if_lvl,
-                   aprepro.ap_file_list.top().lineno);
-          if (--if_lvl < 0) {
-            if_lvl = 0;
-            yyerror("Improperly Nested ifdef/ifndef statements");
-          }
-          /* Ignore endif if not skipping */
-        }
-      }
-      YY_BREAK
-    case 47:
-      YY_RULE_SETUP
-      {
-        BEGIN(GET_FILENAME);
-        file_must_exist = true;
-      }
-      YY_BREAK
-    case 48:
-      YY_RULE_SETUP
-      {
-        BEGIN(GET_FILENAME);
-        file_must_exist = false;
-      }
-      YY_BREAK
-    case 49:
-      /* rule 49 can match eol */
-      YY_RULE_SETUP
-      {
-        BEGIN(INITIAL);
-        {
-          symrec *s;
-          int     quoted = 0;
-          char *  pt     = strchr(yytext, ')');
-          *pt            = '\0';
-          /* Check to see if surrounded by double quote */
-          if ((pt = strchr(yytext, '"')) != nullptr) {
-            yytext++;
-            quoted = 1;
-          }
-          if ((pt = strrchr(yytext, '"')) != nullptr) {
-            *pt    = '\0';
-            quoted = 1;
-          }
+    if (loop_lvl == 0) {
+      BEGIN(INITIAL);
+      aprepro.isCollectingLoop = false;
+    }
+  }
+	YY_BREAK
+case 21:
+/* rule 21 can match eol */
+YY_RULE_SETUP
+{
+    loop_lvl++; /* Nested Loop */
+    aprepro.ap_file_list.top().lineno++;
+  }
+	YY_BREAK
+case 22:
+/* rule 22 can match eol */
+YY_RULE_SETUP
+{
+    if(aprepro.ap_options.interactive ||
+       aprepro.string_interactive())
+    {
+      aprepro.warning("Aborting loops(s).", false);
 
-          if (quoted == 0) {
-            /* See if this is an aprepro variable referring to a name */
-            s = aprepro.getsym(yytext);
-            if (s == nullptr || (s->type != token::SVAR && s->type != token::IMMSVAR)) {
-              pt = yytext;
-            }
-            else {
-              pt = (char *)s->value.svar.c_str();
-            }
-          }
-          else {
-            pt = yytext;
-          }
+      // Leave the looping state
+      BEGIN(INITIAL);
 
-          add_include_file(pt, file_must_exist);
+      loop_lvl = 0;
+      aprepro.isCollectingLoop = false;
+    }
+  }
+	YY_BREAK
+case 23:
+/* rule 23 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+  }
+	YY_BREAK
 
-          if (!aprepro.doIncludeSubstitution)
-            yy_push_state(VERBATIM);
+case 24:
+/* rule 24 can match eol */
+YY_RULE_SETUP
+{
+  yyless(0);
+  curr_index = 0;
+  BEGIN(INITIAL);
+  switch_skip_to_endcase = false;
+}
+	YY_BREAK
+case 25:
+/* rule 25 can match eol */
+YY_RULE_SETUP
+{
+ aprepro.ap_file_list.top().lineno++;
+ if (!switch_active) {
+    yyerror("default statement found outside switch statement.");
+  }
 
-          aprepro.ap_file_list.top().lineno++;
-        }
-      }
-      YY_BREAK
-    case 50:
-    case 51:
-      YY_RULE_SETUP
-      {
-        sscanf(yytext, "%lf", &yylval->val);
-        return (token::NUM);
-      }
-      YY_BREAK
-    case 52:
-      YY_RULE_SETUP; // Empty rule
-      YY_BREAK
-    case 53:
-      YY_RULE_SETUP
-      {
-        symrec *s;
-        s = aprepro.getsym(yytext);
-        if (s == nullptr)
-          s = aprepro.putsym(yytext, SEAMS::Aprepro::SYMBOL_TYPE::UNDEFINED_VARIABLE, 0);
-        yylval->tptr = s;
-        return ((token::yytokentype)s->type);
-      }
-      YY_BREAK
-    case 54:
-      YY_RULE_SETUP
-      return (token::EQUAL);
-      YY_BREAK
-    case 55:
-      YY_RULE_SETUP
-      return (token::EQ_PLUS);
-      YY_BREAK
-    case 56:
-      YY_RULE_SETUP
-      return (token::EQ_MINUS);
-      YY_BREAK
-    case 57:
-      YY_RULE_SETUP
-      return (token::EQ_TIME);
-      YY_BREAK
-    case 58:
-      YY_RULE_SETUP
-      return (token::EQ_DIV);
-      YY_BREAK
-    case 59:
-      YY_RULE_SETUP
-      return (token::EQ_POW);
-      YY_BREAK
-    case 60:
-      YY_RULE_SETUP
-      return (token::EQ_POW);
-      YY_BREAK
-    case 61:
-      YY_RULE_SETUP
-      return (token::INC);
-      YY_BREAK
-    case 62:
-      YY_RULE_SETUP
-      return (token::DEC);
-      YY_BREAK
-    case 63:
-      YY_RULE_SETUP
-      return (token::PLU);
-      YY_BREAK
-    case 64:
-      YY_RULE_SETUP
-      return (token::SUB);
-      YY_BREAK
-    case 65:
-      YY_RULE_SETUP
-      return (token::TIM);
-      YY_BREAK
-    case 66:
-      YY_RULE_SETUP
-      return (token::TIM); /* ~ is same as multiply */
-      YY_BREAK
-    case 67:
-      YY_RULE_SETUP
-      return (token::CONCAT); /* String concatenation */
-      YY_BREAK
-    case 68:
-      YY_RULE_SETUP
-      return (token::DIV);
-      YY_BREAK
-    case 69:
-      YY_RULE_SETUP
-      return (token::MOD);
-      YY_BREAK
-    case 70:
-      YY_RULE_SETUP
-      return (token::POW);
-      YY_BREAK
-    case 71:
-      YY_RULE_SETUP
-      return (token::POW);
-      YY_BREAK
-    case 72:
-      /* rule 72 can match eol */
-      YY_RULE_SETUP
-      aprepro.ap_file_list.top().lineno++;
-      YY_BREAK
-    case 73:
-      YY_RULE_SETUP
-      return (token::LPAR);
-      YY_BREAK
-    case 74:
-      YY_RULE_SETUP
-      return (token::RPAR);
-      YY_BREAK
-    case 75:
-      YY_RULE_SETUP
-      return (token::COMMA);
-      YY_BREAK
-    case 76:
-      YY_RULE_SETUP
-      return (token::SEMI);
-      YY_BREAK
-    case 77:
-      YY_RULE_SETUP
-      return (token::COLON);
-      YY_BREAK
-    case 78:
-      YY_RULE_SETUP
-      return (token::QUEST);
-      YY_BREAK
-    case 79:
-      YY_RULE_SETUP
-      return (token::LT);
-      YY_BREAK
-    case 80:
-      YY_RULE_SETUP
-      return (token::GT);
-      YY_BREAK
-    case 81:
-      YY_RULE_SETUP
-      return (token::LE);
-      YY_BREAK
-    case 82:
-      YY_RULE_SETUP
-      return (token::GE);
-      YY_BREAK
-    case 83:
-      YY_RULE_SETUP
-      return (token::EQ);
-      YY_BREAK
-    case 84:
-      YY_RULE_SETUP
-      return (token::NE);
-      YY_BREAK
-    case 85:
-      YY_RULE_SETUP
-      return (token::LAND);
-      YY_BREAK
-    case 86:
-      YY_RULE_SETUP
-      return (token::LOR);
-      YY_BREAK
-    case 87:
-      YY_RULE_SETUP
-      return (token::NOT);
-      YY_BREAK
-    case 88:
-      YY_RULE_SETUP
-      return (token::LBRACK);
-      YY_BREAK
-    case 89:
-      YY_RULE_SETUP
-      return (token::RBRACK);
-      YY_BREAK
-    case 90:
-      /* rule 90 can match eol */
-      YY_RULE_SETUP
-      {
-        char *pt = strrchr(yytext, '"');
-        *pt      = '\0';
-        new_string(yytext + 1, &yylval->string);
-        return token::QSTRING;
-      }
-      YY_BREAK
-    case 91:
-      /* rule 91 can match eol */
-      YY_RULE_SETUP
-      {
-        char *pt = strrchr(yytext, '\'');
-        *pt      = '\0';
-        new_string(yytext + 1, &yylval->string);
-        return token::QSTRING;
-      }
-      YY_BREAK
-    case 92:
-      YY_RULE_SETUP
-      {
-        // Add to the history string
-        save_history_string();
-
-        if (switch_skip_to_endcase)
-          BEGIN(END_CASE_SKIP);
-        else
-          BEGIN(if_state[if_lvl]);
-        return (token::RBRACE);
-      }
-      YY_BREAK
-    case 93:
-      YY_RULE_SETUP
-      {
-        if (echo)
-          LexerOutput("{", 1);
-      }
-      YY_BREAK
-    case 94:
-      YY_RULE_SETUP
-      {
-        if (echo)
-          LexerOutput("}", 1);
-      }
-      YY_BREAK
-    case 95:
-      YY_RULE_SETUP
-      {
-        // Check if we need to save the substitution history first.
-        if (aprepro.ap_options.keep_history && (aprepro.ap_file_list.top().name != "_string_")) {
-          if (curr_index > (size_t)yyleng)
-            hist_start = curr_index - yyleng;
-          else
-            hist_start = 0;
-        }
+  if (!switch_case_run) {
+    switch_case_run = true;
+    BEGIN(INITIAL);
+    switch_skip_to_endcase = false;
+    if (aprepro.ap_options.debugging)
+      fprintf (stderr, "DEBUG SWITCH: 'default' code executing at line %d\n",
+               aprepro.ap_file_list.top().lineno);
+  }
+  else {
+    if (aprepro.ap_options.debugging)
+      fprintf (stderr, "DEBUG SWITCH: 'default' not executing since a previous case already ran at line %d\n",
+               aprepro.ap_file_list.top().lineno);
 
-        BEGIN(PARSING);
+    /* Need to skip all code until end of case */
+    BEGIN(END_CASE_SKIP);
+  }
+}
+	YY_BREAK
+case 26:
+/* rule 26 can match eol */
+YY_RULE_SETUP
+{
+  aprepro.ap_file_list.top().lineno++;
+  BEGIN(INITIAL);
+  switch_active = false;
+  switch_skip_to_endcase = false;
+  suppress_nl = false;
+  if (aprepro.ap_options.debugging)
+    fprintf (stderr, "DEBUG SWITCH: 'endswitch' at line %d\n",
+	     aprepro.ap_file_list.top().lineno);
+}
+	YY_BREAK
+case 27:
+/* rule 27 can match eol */
+YY_RULE_SETUP
+{  aprepro.ap_file_list.top().lineno++; }
+	YY_BREAK
+case 28:
+/* rule 28 can match eol */
+YY_RULE_SETUP
+{
+  aprepro.ap_file_list.top().lineno++;
+  if (!switch_active) {
+    yyerror("endswitch statement found without matching switch.");
+  }
+  switch_active = false;
+  switch_skip_to_endcase = false;
+}
+	YY_BREAK
 
-        return (token::LBRACE);
-      }
-      YY_BREAK
-    case 96:
-    case 97:
-      YY_RULE_SETUP
-      {
-        if (aprepro.ap_options.end_on_exit) {
-          if (echo)
-            ECHO;
-          return ((token::yytokentype)-1);
-        }
-        else if (echo)
-          ECHO;
-      }
-      YY_BREAK
-    case 98:
-      YY_RULE_SETUP
-      {
-        if (echo)
-          ECHO;
-      }
-      YY_BREAK
-    case 99:
-    case 100:
-      YY_RULE_SETUP
-      {
-        if (echo && if_state[if_lvl] != IF_SKIP)
-          ECHO;
-      }
-      YY_BREAK
-    case 101:
-      /* rule 101 can match eol */
-      YY_RULE_SETUP
-      {
-        if (echo && !suppress_nl)
-          ECHO;
-        suppress_nl = false;
-        aprepro.ap_file_list.top().lineno++;
-      }
-      YY_BREAK
-    case 102:
-      YY_RULE_SETUP
-      ECHO;
-      YY_BREAK
-    case YY_STATE_EOF(INITIAL):
-    case YY_STATE_EOF(PARSING):
-    case YY_STATE_EOF(GET_FILENAME):
-    case YY_STATE_EOF(IF_SKIP):
-    case YY_STATE_EOF(GET_VAR):
-    case YY_STATE_EOF(VERBATIM):
-    case YY_STATE_EOF(IF_WHILE_SKIP):
-    case YY_STATE_EOF(GET_LOOP_VAR):
-    case YY_STATE_EOF(LOOP):
-    case YY_STATE_EOF(LOOP_SKIP):
-    case YY_STATE_EOF(END_CASE_SKIP): yyterminate();
-
-    case YY_END_OF_BUFFER: {
-      /* Amount of text matched not including the EOB char. */
-      int yy_amount_of_matched_text = (int)(yy_cp - (yytext_ptr)) - 1;
-
-      /* Undo the effects of YY_DO_BEFORE_ACTION. */
-      *yy_cp = (yy_hold_char);
-      YY_RESTORE_YY_MORE_OFFSET
-
-      if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW) {
-        /* We're scanning a new file or input source.  It's
-         * possible that this happened because the user
-         * just pointed yyin at a new source and called
-         * yylex().  If so, then we have to assure
-         * consistency between YY_CURRENT_BUFFER and our
-         * globals.  Here is the right place to do so, because
-         * this is the first action (other than possibly a
-         * back-up) that will match for the new input source.
-         */
-        (yy_n_chars)                               = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-        YY_CURRENT_BUFFER_LVALUE->yy_input_file    = yyin;
-        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-      }
+/* This restores the old behavior of ifdef and ifndef
+   * where they would eat up any leading whitespace on
+   * a line.
+   */
+case 29:
+YY_RULE_SETUP
+{
+    // Used to avoid undefined variable warnings in old ifdef/ifndef construct
+    aprepro.inIfdefGetvar = true;
+    unput('(');
+    unput('f');
+    unput('e');
+    unput('d');
+    unput('f');
+    unput('i');
+    unput('_');
+    unput('{');
+  }
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+{
+    // Used to avoid undefined variable warnings in old ifdef/ifndef construct
+    aprepro.inIfdefGetvar = true;
+    unput('(');
+    unput('f');
+    unput('e');
+    unput('d');
+    unput('n');
+    unput('f');
+    unput('i');
+    unput('_');
+    unput('{');
+  }
+	YY_BREAK
 
-      /* Note that here we test for yy_c_buf_p "<=" to the position
-       * of the first EOB in the buffer, since yy_c_buf_p will
-       * already have been incremented past the NUL character
-       * (since all states make transitions on EOB to the
-       * end-of-buffer state).  Contrast this with the test
-       * in input().
-       */
-      if ((yy_c_buf_p) <=
-          &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]) { /* This was really a NUL. */
-        yy_state_type yy_next_state;
-
-        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-
-        yy_current_state = yy_get_previous_state();
-
-        /* Okay, we're now positioned to make the NUL
-         * transition.  We couldn't have
-         * yy_get_previous_state() go ahead and do it
-         * for us because it doesn't know how to deal
-         * with the possibility of jamming (and we don't
-         * want to build jamming into it because then it
-         * will run more slowly).
-         */
+/* If an if was found while skipping, then eat
+   * that entire if block until endif
+   * found since there is no way that
+   * any of the code in that if block could be executed.
+   * Make sure to handle multiple levels of skipped ifs...
+   *
+   * NOTE: if_lvl was not incremented, so don't need to decrement when
+   *       endif found.
+   */
+case 31:
+/* rule 31 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+    if (--if_skip_level == 0)
+      BEGIN(IF_SKIP);
+  }
+	YY_BREAK
+case 32:
+/* rule 32 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+    if_skip_level++;
+  }
+	YY_BREAK
+case 33:
+/* rule 33 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+    if_skip_level++;
+  }
+	YY_BREAK
+case 34:
+/* rule 34 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+    if_skip_level++;
+  }
+	YY_BREAK
+case 35:
+/* rule 35 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
+  }
+	YY_BREAK
 
-        yy_next_state = yy_try_NUL_trans(yy_current_state);
+/* IF an if, ifdef, or ifndef found while skipping, then
+   * skip the entire block up and including the endif.
+   * The (IF_WHILE_SKIP) start condition handles this skipping.
+   */
+case 36:
+YY_RULE_SETUP
+{
+    if (aprepro.ap_options.debugging)
+      fprintf (stderr, "DEBUG IF: 'ifdef'  found while skipping at line %d\n",
+               aprepro.ap_file_list.top().lineno);
+    if_skip_level = 1;
+    BEGIN(IF_WHILE_SKIP);
+  }
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+{
+    if (aprepro.ap_options.debugging)
+      fprintf (stderr, "DEBUG IF: 'ifdef'  found while skipping at line %d\n",
+               aprepro.ap_file_list.top().lineno);
+    if_skip_level = 1;
+    BEGIN(IF_WHILE_SKIP);
+  }
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+{
+    if (aprepro.ap_options.debugging)
+      fprintf (stderr, "DEBUG IF: 'ifndef'  found while skipping at line %d\n",
+               aprepro.ap_file_list.top().lineno);
+    if_skip_level = 1;
+    BEGIN(IF_WHILE_SKIP);
+  }
+	YY_BREAK
 
-        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+case 39:
+/* rule 39 can match eol */
+YY_RULE_SETUP
+{
+  aprepro.ap_file_list.top().lineno++;
+  if (aprepro.ap_options.debugging)
+    fprintf (stderr, "DEBUG IF: 'else'   at level = %d at line %d\n",
+             if_lvl, aprepro.ap_file_list.top().lineno);
+  if(YY_START == VERBATIM) {
+    if(echo) ECHO;
+  }
+  else if (if_state[if_lvl] == IF_SKIP) {
+    if (!if_case_run[if_lvl]) {
+      BEGIN(INITIAL);
+      if_state[if_lvl] = INITIAL;
+      if_case_run[if_lvl] = true;
+    } else {
+      BEGIN(IF_SKIP);
+      if_state[if_lvl] = IF_SKIP;
+    }
+  }
+  else if (if_state[if_lvl] == INITIAL) {
+    BEGIN(IF_SKIP);
+    if_state[if_lvl] = IF_SKIP;
+  }
 
-        if (yy_next_state) {
-          /* Consume the NUL. */
-          yy_cp            = ++(yy_c_buf_p);
-          yy_current_state = yy_next_state;
-          goto yy_match;
-        }
+  /* If neither is true, this is a nested
+     if that should be skipped */
+}
+	YY_BREAK
 
-        else {
-          /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
-          yy_cp = (yy_c_buf_p);
-          goto yy_find_action;
-        }
-      }
+case 40:
+/* rule 40 can match eol */
+YY_RULE_SETUP
+{
+    /* If any previous 'block' of this if has executed, then
+     * just skip this block; otherwise see if condition is
+     * true and execute this block
+     */
+    if (aprepro.ap_options.debugging)
+      fprintf (stderr, "DEBUG IF: 'elseif'   at level = %d at line %d\n",
+               if_lvl, aprepro.ap_file_list.top().lineno);
 
-      else
-        switch (yy_get_next_buffer()) {
-        case EOB_ACT_END_OF_FILE: {
-          (yy_did_buffer_switch_on_eof) = 0;
-
-          if (yywrap()) {
-            /* Note: because we've taken care in
-             * yy_get_next_buffer() to have set up
-             * yytext, we can now set up
-             * yy_c_buf_p so that if some total
-             * hoser (like flex itself) wants to
-             * call the scanner after we return the
-             * YY_NULL, it'll still work - another
-             * YY_NULL will get returned.
-             */
-            (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-
-            yy_act = YY_STATE_EOF(YY_START);
-            goto do_action;
-          }
+    if (if_case_run[if_lvl]) { /* A previous else/elseif has run */
+      aprepro.ap_file_list.top().lineno++;
+      /* Already in IF_SKIP, so don't need to change state */
+    } else {
+      /* Need to check the elseif condition; push back and parse */
+      yyless(0);
+      curr_index = 0;
+      BEGIN(INITIAL);
+      if_state[if_lvl] = INITIAL;
+    }
+  }
+	YY_BREAK
+case 41:
+case 42:
+case 43:
+case 44:
+YY_RULE_SETUP
+{ ; }
+	YY_BREAK
+case 45:
+/* rule 45 can match eol */
+YY_RULE_SETUP
+{
+     aprepro.ap_file_list.top().lineno++;
+   }
+	YY_BREAK
 
-          else {
-            if (!(yy_did_buffer_switch_on_eof))
-              YY_NEW_FILE;
-          }
-          break;
-        }
+case 46:
+/* rule 46 can match eol */
+YY_RULE_SETUP
+{
+    aprepro.ap_file_list.top().lineno++;
 
-        case EOB_ACT_CONTINUE_SCAN:
-          (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+    if(YY_START == VERBATIM) {
+      if(echo) ECHO;
+    }
+    else {
+      if (if_state[if_lvl] == IF_SKIP ||
+          if_state[if_lvl] == INITIAL) {
+            BEGIN(INITIAL);
+	    suppress_nl = false;
+      }
+                           /* If neither is true, this is a nested
+                              if that should be skipped */
+      if (aprepro.ap_options.debugging)
+        printf ("DEBUG IF: 'endif'  at level = %d at line %d\n",
+                if_lvl, aprepro.ap_file_list.top().lineno);
+      if (--if_lvl < 0) {
+        if_lvl = 0;
+        yyerror("Improperly Nested ifdef/ifndef statements");
+      }
+      /* Ignore endif if not skipping */
+    }
+  }
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+{ BEGIN(GET_FILENAME);
+                             file_must_exist = true; }
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+{ BEGIN(GET_FILENAME);
+                             file_must_exist = false; }
+	YY_BREAK
+case 49:
+/* rule 49 can match eol */
+YY_RULE_SETUP
+{
+  BEGIN(INITIAL);
+  {
+    symrec *s;
+    int quoted = 0;
+    char *pt = strchr(yytext, ')');
+    *pt = '\0';
+    /* Check to see if surrounded by double quote */
+    if ((pt = strchr(yytext, '"')) != nullptr) {
+      yytext++;
+      quoted = 1;
+    }
+    if ((pt = strrchr(yytext, '"')) != nullptr) {
+      *pt = '\0';
+      quoted = 1;
+    }
 
-          yy_current_state = yy_get_previous_state();
+    if (quoted == 0) {
+      /* See if this is an aprepro variable referring to a name */
+      s = aprepro.getsym(yytext);
+      if (s == nullptr || (s->type != token::SVAR && s->type != token::IMMSVAR)) {
+        pt = yytext;
+      } else {
+        pt = (char*)s->value.svar.c_str();
+      }
+    } else {
+      pt = yytext;
+    }
 
-          yy_cp = (yy_c_buf_p);
-          yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-          goto yy_match;
+    add_include_file(pt, file_must_exist);
 
-        case EOB_ACT_LAST_MATCH:
-          (yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+    if(!aprepro.doIncludeSubstitution)
+      yy_push_state(VERBATIM);
 
-          yy_current_state = yy_get_previous_state();
+    aprepro.ap_file_list.top().lineno++;
+  }
+}
+	YY_BREAK
+case 50:
+case 51:
+YY_RULE_SETUP
+{ sscanf (yytext, "%lf", &yylval->val);
+                       return(token::NUM); }
+	YY_BREAK
+case 52:
+YY_RULE_SETUP
+; // Empty rule
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+{
+           symrec *s;
+                             s = aprepro.getsym(yytext);
+                             if (s == nullptr)
+                               s = aprepro.putsym (yytext, SEAMS::Aprepro::SYMBOL_TYPE::UNDEFINED_VARIABLE, 0);
+                             yylval->tptr = s;
+                             return((token::yytokentype)s->type);
+                           }
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+return(token::EQUAL);
+	YY_BREAK
+case 55:
+YY_RULE_SETUP
+return(token::EQ_PLUS);
+	YY_BREAK
+case 56:
+YY_RULE_SETUP
+return(token::EQ_MINUS);
+	YY_BREAK
+case 57:
+YY_RULE_SETUP
+return(token::EQ_TIME);
+	YY_BREAK
+case 58:
+YY_RULE_SETUP
+return(token::EQ_DIV);
+	YY_BREAK
+case 59:
+YY_RULE_SETUP
+return(token::EQ_POW);
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+return(token::EQ_POW);
+	YY_BREAK
+case 61:
+YY_RULE_SETUP
+return(token::INC);
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+return(token::DEC);
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+return(token::PLU);
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+return(token::SUB);
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
+return(token::TIM);
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
+return(token::TIM);          /* ~ is same as multiply */
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
+return(token::CONCAT);       /* String concatenation */
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+return(token::DIV);
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
+return(token::MOD);
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+return(token::POW);
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
+return(token::POW);
+	YY_BREAK
+case 72:
+/* rule 72 can match eol */
+YY_RULE_SETUP
+aprepro.ap_file_list.top().lineno++;
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
+return(token::LPAR);
+	YY_BREAK
+case 74:
+YY_RULE_SETUP
+return(token::RPAR);
+	YY_BREAK
+case 75:
+YY_RULE_SETUP
+return(token::COMMA);
+	YY_BREAK
+case 76:
+YY_RULE_SETUP
+return(token::SEMI);
+	YY_BREAK
+case 77:
+YY_RULE_SETUP
+return(token::COLON);
+	YY_BREAK
+case 78:
+YY_RULE_SETUP
+return(token::QUEST);
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
+return(token::LT);
+	YY_BREAK
+case 80:
+YY_RULE_SETUP
+return(token::GT);
+	YY_BREAK
+case 81:
+YY_RULE_SETUP
+return(token::LE);
+	YY_BREAK
+case 82:
+YY_RULE_SETUP
+return(token::GE);
+	YY_BREAK
+case 83:
+YY_RULE_SETUP
+return(token::EQ);
+	YY_BREAK
+case 84:
+YY_RULE_SETUP
+return(token::NE);
+	YY_BREAK
+case 85:
+YY_RULE_SETUP
+return(token::LAND);
+	YY_BREAK
+case 86:
+YY_RULE_SETUP
+return(token::LOR);
+	YY_BREAK
+case 87:
+YY_RULE_SETUP
+return(token::NOT);
+	YY_BREAK
+case 88:
+YY_RULE_SETUP
+return(token::LBRACK);
+	YY_BREAK
+case 89:
+YY_RULE_SETUP
+return(token::RBRACK);
+	YY_BREAK
+case 90:
+/* rule 90 can match eol */
+YY_RULE_SETUP
+{
+           char *pt = strrchr(yytext, '"');
+                             *pt = '\0';
+                             new_string(yytext+1, &yylval->string);
+                             return token::QSTRING; }
+	YY_BREAK
+case 91:
+/* rule 91 can match eol */
+YY_RULE_SETUP
+{
+           char *pt = strrchr(yytext, '\'');
+                             *pt = '\0';
+                             new_string(yytext+1, &yylval->string);
+                             return token::QSTRING; }
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
+{
+  // Add to the history string
+  save_history_string();
 
-          yy_cp = (yy_c_buf_p);
-          yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-          goto yy_find_action;
-        }
-      break;
+  if (switch_skip_to_endcase)
+    BEGIN(END_CASE_SKIP);
+  else
+    BEGIN(if_state[if_lvl]);
+  return(token::RBRACE);
+}
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
+{ if (echo) LexerOutput("{", 1); }
+	YY_BREAK
+case 94:
+YY_RULE_SETUP
+{ if (echo) LexerOutput("}", 1); }
+	YY_BREAK
+case 95:
+YY_RULE_SETUP
+{
+    // Check if we need to save the substitution history first.
+    if(aprepro.ap_options.keep_history &&
+            (aprepro.ap_file_list.top().name != "_string_"))
+    {
+      if (curr_index > (size_t)yyleng)
+        hist_start = curr_index - yyleng;
+      else
+        hist_start = 0;
     }
 
-    default: YY_FATAL_ERROR("fatal flex scanner internal error--no action found");
-    } /* end of action switch */
-  }   /* end of scanning one token */
+    BEGIN(PARSING);
+
+    return(token::LBRACE);
+  }
+	YY_BREAK
+case 96:
+case 97:
+YY_RULE_SETUP
+{
+  if (aprepro.ap_options.end_on_exit) {
+    if (echo) ECHO;
+    return((token::yytokentype)-1);
+  }
+  else
+    if (echo) ECHO;
+}
+	YY_BREAK
+case 98:
+YY_RULE_SETUP
+{ if (echo) ECHO; }
+	YY_BREAK
+case 99:
+case 100:
+YY_RULE_SETUP
+{ if (echo && if_state[if_lvl] != IF_SKIP) ECHO; }
+	YY_BREAK
+case 101:
+/* rule 101 can match eol */
+YY_RULE_SETUP
+{ if (echo && !suppress_nl) ECHO; suppress_nl = false;
+                             aprepro.ap_file_list.top().lineno++;}
+	YY_BREAK
+case 102:
+YY_RULE_SETUP
+ECHO;
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(PARSING):
+case YY_STATE_EOF(GET_FILENAME):
+case YY_STATE_EOF(IF_SKIP):
+case YY_STATE_EOF(GET_VAR):
+case YY_STATE_EOF(VERBATIM):
+case YY_STATE_EOF(IF_WHILE_SKIP):
+case YY_STATE_EOF(GET_LOOP_VAR):
+case YY_STATE_EOF(LOOP):
+case YY_STATE_EOF(LOOP_SKIP):
+case YY_STATE_EOF(END_CASE_SKIP):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = (yy_hold_char);
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state(  );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++(yy_c_buf_p);
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
+				yy_cp = (yy_c_buf_p);
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer(  ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				(yy_did_buffer_switch_on_eof) = 0;
+
+				if ( yywrap(  ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				(yy_c_buf_p) =
+					(yytext_ptr) + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				(yy_c_buf_p) =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
 } /* end of yylex */
 /* %ok-for-header */
 
@@ -2308,87 +2656,92 @@ YY_DECL
 
 /* The contents of this function are C++ specific, so the () macro is not used.
  */
-yyFlexLexer::yyFlexLexer(std::istream *arg_yyin, std::ostream *arg_yyout)
+yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
 {
-  yyin          = arg_yyin;
-  yyout         = arg_yyout;
-  yy_c_buf_p    = nullptr;
-  yy_init       = 0;
-  yy_start      = 0;
-  yy_flex_debug = 0;
-  yylineno      = 1; // this will only get updated if %option yylineno
+	yyin = arg_yyin;
+	yyout = arg_yyout;
+	yy_c_buf_p = 0;
+	yy_init = 0;
+	yy_start = 0;
+	yy_flex_debug = 0;
+	yylineno = 1;	// this will only get updated if %option yylineno
+
+	yy_did_buffer_switch_on_eof = 0;
 
-  yy_did_buffer_switch_on_eof = 0;
+	yy_looking_for_trail_begin = 0;
+	yy_more_flag = 0;
+	yy_more_len = 0;
+	yy_more_offset = yy_prev_more_offset = 0;
 
-  yy_looking_for_trail_begin = 0;
-  yy_more_flag               = 0;
-  yy_more_len                = 0;
-  yy_more_offset = yy_prev_more_offset = 0;
+	yy_start_stack_ptr = yy_start_stack_depth = 0;
+	yy_start_stack = NULL;
 
-  yy_start_stack_ptr = yy_start_stack_depth = 0;
-  yy_start_stack                            = NULL;
+	yy_buffer_stack = 0;
+	yy_buffer_stack_top = 0;
+	yy_buffer_stack_max = 0;
 
-  yy_buffer_stack     = nullptr;
-  yy_buffer_stack_top = 0;
-  yy_buffer_stack_max = 0;
+	yy_state_buf = 0;
 
-  yy_state_buf = nullptr;
 }
 
 /* The contents of this function are C++ specific, so the () macro is not used.
  */
 yyFlexLexer::~yyFlexLexer()
 {
-  delete[] yy_state_buf;
-  SEAMSfree(yy_start_stack);
-  yy_delete_buffer(YY_CURRENT_BUFFER);
-  SEAMSfree(yy_buffer_stack);
+	delete [] yy_state_buf;
+	SEAMSfree(yy_start_stack  );
+	yy_delete_buffer( YY_CURRENT_BUFFER );
+	SEAMSfree(yy_buffer_stack  );
 }
 
 /* The contents of this function are C++ specific, so the () macro is not used.
  */
-void yyFlexLexer::switch_streams(std::istream *new_in, std::ostream *new_out)
+void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
 {
-  if (new_in) {
-    yy_delete_buffer(YY_CURRENT_BUFFER);
-    yy_switch_to_buffer(yy_create_buffer(new_in, YY_BUF_SIZE));
-  }
-
-  if (new_out)
-    yyout = new_out;
+	if ( new_in )
+		{
+		yy_delete_buffer( YY_CURRENT_BUFFER );
+		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  ) );
+		}
+
+	if ( new_out )
+		yyout = new_out;
 }
 
 #ifdef YY_INTERACTIVE
-int yyFlexLexer::LexerInput(char *buf, int /* max_size */)
+int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
 #else
-int yyFlexLexer::LexerInput(char *buf, int max_size)
+int yyFlexLexer::LexerInput( char* buf, int max_size )
 #endif
 {
-  if (yyin->eof() || yyin->fail())
-    return 0;
+	if ( yyin->eof() || yyin->fail() )
+		return 0;
 
 #ifdef YY_INTERACTIVE
-  yyin->get(buf[0]);
+	yyin->get( buf[0] );
 
-  if (yyin->eof())
-    return 0;
+	if ( yyin->eof() )
+		return 0;
 
-  if (yyin->bad())
-    return -1;
+	if ( yyin->bad() )
+		return -1;
 
-  return 1;
+	return 1;
 
 #else
-  (void)yyin->read(buf, max_size);
+	(void) yyin->read( buf, max_size );
 
-  if (yyin->bad())
-    return -1;
-  else
-    return yyin->gcount();
+	if ( yyin->bad() )
+		return -1;
+	else
+		return yyin->gcount();
 #endif
 }
 
-void yyFlexLexer::LexerOutput(const char *buf, int size) { (void)yyout->write(buf, size); }
+void yyFlexLexer::LexerOutput( const char* buf, int size )
+{
+	(void) yyout->write( buf, size );
+}
 /* %ok-for-header */
 
 /* %endif */
@@ -2396,9 +2749,9 @@ void yyFlexLexer::LexerOutput(const char *buf, int size) { (void)yyout->write(bu
 /* yy_get_next_buffer - try to read in a new buffer
  *
  * Returns a code representing an action:
- *      EOB_ACT_LAST_MATCH -
- *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *      EOB_ACT_END_OF_FILE - end of file
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
  */
 /* %if-c-only */
 /* %endif */
@@ -2406,119 +2759,134 @@ void yyFlexLexer::LexerOutput(const char *buf, int size) { (void)yyout->write(bu
 int yyFlexLexer::yy_get_next_buffer()
 /* %endif */
 {
-  char *dest   = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-  char *source = (yytext_ptr);
-  int   number_to_move, i;
-  int   ret_val;
-
-  if ((yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1])
-    YY_FATAL_ERROR("fatal flex scanner internal error--end of buffer missed");
-
-  if (YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer ==
-      0) { /* Don't try to fill the buffer, so this is an EOF. */
-    if ((yy_c_buf_p) - (yytext_ptr)-YY_MORE_ADJ == 1) {
-      /* We matched a single character, the EOB, so
-       * treat this as a final EOF.
-       */
-      return EOB_ACT_END_OF_FILE;
-    }
-
-    else {
-      /* We matched some text prior to the EOB, first
-       * process it.
-       */
-      return EOB_ACT_LAST_MATCH;
-    }
-  }
-
-  /* Try to read more data. */
-
-  /* First move last chars to start of buffer. */
-  number_to_move = (int)((yy_c_buf_p) - (yytext_ptr)) - 1;
-
-  for (i = 0; i < number_to_move; ++i)
-    *(dest++) = *(source++);
-
-  if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING)
-    /* don't do the read, it's not guaranteed to return an EOF,
-     * just force an EOF
-     */
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-
-  else {
-    yy_size_t num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-    while (num_to_read <= 0) { /* Not enough room in the buffer - grow it. */
-
-      /* just a shorter name for the current buffer */
-      YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
-
-      int yy_c_buf_p_offset = (int)((yy_c_buf_p)-b->yy_ch_buf);
-
-      if (b->yy_is_our_buffer) {
-        yy_size_t new_size = b->yy_buf_size * 2;
-
-        if (new_size <= 0)
-          b->yy_buf_size += b->yy_buf_size / 8;
-        else
-          b->yy_buf_size *= 2;
-
-        b->yy_ch_buf = (char *)
-            /* Include room in for 2 EOB chars. */
-            SEAMSrealloc((void *)b->yy_ch_buf, b->yy_buf_size + 2);
-      }
-      else
-        /* Can't grow it, we don't own it. */
-        b->yy_ch_buf = nullptr;
-
-      if (!b->yy_ch_buf)
-        YY_FATAL_ERROR("fatal error - scanner input buffer overflow");
-
-      (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-    }
-
-    if (num_to_read > YY_READ_BUF_SIZE)
-      num_to_read = YY_READ_BUF_SIZE;
-
-    /* Read in more data. */
-    YY_INPUT((&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), (yy_n_chars), num_to_read);
-
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-  }
+    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	register char *source = (yytext_ptr);
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+	else
+		{
+			yy_size_t num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				yy_size_t new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					SEAMSrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			(yy_n_chars), num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	if ( (yy_n_chars) == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) SEAMSrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+	}
+
+	(yy_n_chars) += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
-  if ((yy_n_chars) == 0) {
-    if (number_to_move == YY_MORE_ADJ) {
-      ret_val = EOB_ACT_END_OF_FILE;
-      yyrestart(yyin);
-    }
-
-    else {
-      ret_val                                    = EOB_ACT_LAST_MATCH;
-      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING;
-    }
-  }
-
-  else
-    ret_val = EOB_ACT_CONTINUE_SCAN;
-
-  if ((yy_size_t)((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-    /* Extend the array by 50%, plus the number we really need. */
-    yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf =
-        (char *)SEAMSrealloc((void *)YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size);
-    if (!YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
-      YY_FATAL_ERROR("out of dynamic memory in yy_get_next_buffer()");
-  }
-
-  (yy_n_chars) += number_to_move;
-  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]     = YY_END_OF_BUFFER_CHAR;
-  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-
-  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-  return ret_val;
+	return ret_val;
 }
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
@@ -2528,101 +2896,110 @@ int yyFlexLexer::yy_get_next_buffer()
 
 /* %endif */
 /* %if-c++-only */
-yy_state_type yyFlexLexer::yy_get_previous_state()
+    yy_state_type yyFlexLexer::yy_get_previous_state()
 /* %endif */
 {
-  yy_state_type yy_current_state;
-  char *        yy_cp;
-
-  /* %% [15.0] code to get the start state into yy_current_state goes here */
-  yy_current_state = (yy_start);
-
-  for (yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp) {
-    /* %% [16.0] code to find the next state goes here */
-    YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-    if (yy_accept[yy_current_state]) {
-      (yy_last_accepting_state) = yy_current_state;
-      (yy_last_accepting_cpos)  = yy_cp;
-    }
-    while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
-      yy_current_state = (int)yy_def[yy_current_state];
-      if (yy_current_state >= 703)
-        yy_c = yy_meta[(unsigned int)yy_c];
-    }
-    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
-  }
-
-  return yy_current_state;
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+    
+/* %% [15.0] code to get the start state into yy_current_state goes here */
+	yy_current_state = (yy_start);
+
+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+		{
+/* %% [16.0] code to find the next state goes here */
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			(yy_last_accepting_state) = yy_current_state;
+			(yy_last_accepting_cpos) = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 703 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		}
+
+	return yy_current_state;
 }
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
- *      next_state = yy_try_NUL_trans( current_state );
+ *	next_state = yy_try_NUL_trans( current_state );
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-yy_state_type yyFlexLexer::yy_try_NUL_trans(yy_state_type yy_current_state)
+    yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
 /* %endif */
 {
-  int yy_is_jam;
-  /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
-  char *yy_cp = (yy_c_buf_p);
-
-  YY_CHAR yy_c = 1;
-  if (yy_accept[yy_current_state]) {
-    (yy_last_accepting_state) = yy_current_state;
-    (yy_last_accepting_cpos)  = yy_cp;
-  }
-  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
-    yy_current_state = (int)yy_def[yy_current_state];
-    if (yy_current_state >= 703)
-      yy_c = yy_meta[(unsigned int)yy_c];
-  }
-  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
-  yy_is_jam        = (yy_current_state == 702);
-
-  return yy_is_jam ? 0 : yy_current_state;
+	register int yy_is_jam;
+    /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
+	register char *yy_cp = (yy_c_buf_p);
+
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		(yy_last_accepting_state) = yy_current_state;
+		(yy_last_accepting_cpos) = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 703 )
+			yy_c = yy_meta[(unsigned int) yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+	yy_is_jam = (yy_current_state == 702);
+
+		return yy_is_jam ? 0 : yy_current_state;
 }
 
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yyunput(int c, char *yy_bp)
+    void yyFlexLexer::yyunput( int c, register char* yy_bp)
 /* %endif */
 {
-  char *yy_cp;
-
-  yy_cp = (yy_c_buf_p);
+	register char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
 
-  /* undo effects of setting up yytext */
-  *yy_cp = (yy_hold_char);
+	/* undo effects of setting up yytext */
+	*yy_cp = (yy_hold_char);
 
-  if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2) { /* need to shift things up to make room */
-                                                         /* +2 for EOB chars. */
-    yy_size_t number_to_move = (yy_n_chars) + 2;
-    char *dest   = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
-    char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register yy_size_t number_to_move = (yy_n_chars) + 2;
+		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		register char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
-    while (source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
-      *--dest = *--source;
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
 
-    yy_cp += (int)(dest - source);
-    yy_bp += (int)(dest - source);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
-    if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2)
-      YY_FATAL_ERROR("flex scanner push-back overflow");
-  }
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
 
-  *--yy_cp = (char)c;
+	*--yy_cp = (char) c;
 
-  /* %% [18.0] update yylineno here */
+/* %% [18.0] update yylineno here */
 
-  (yytext_ptr)   = yy_bp;
-  (yy_hold_char) = *yy_cp;
-  (yy_c_buf_p)   = yy_cp;
+	(yytext_ptr) = yy_bp;
+	(yy_hold_char) = *yy_cp;
+	(yy_c_buf_p) = yy_cp;
 }
 /* %if-c-only */
 /* %endif */
@@ -2630,198 +3007,206 @@ void yyFlexLexer::yyunput(int c, char *yy_bp)
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-int yyFlexLexer::yyinput()
+    int yyFlexLexer::yyinput()
 /* %endif */
 {
-  int c;
-
-  *(yy_c_buf_p) = (yy_hold_char);
-
-  if (*(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR) {
-    /* yy_c_buf_p now points to the character we want to return.
-     * If this occurs *before* the EOB characters, then it's a
-     * valid NUL; if not, then we've hit the end of the buffer.
-     */
-    if ((yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)])
-      /* This was really a NUL. */
-      *(yy_c_buf_p) = '\0';
-
-    else { /* need more input */
-      yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
-      ++(yy_c_buf_p);
-
-      switch (yy_get_next_buffer()) {
-      case EOB_ACT_LAST_MATCH:
-        /* This happens because yy_g_n_b()
-         * sees that we've accumulated a
-         * token and flags that we need to
-         * try matching the token before
-         * proceeding.  But for input(),
-         * there's no matching to consider.
-         * So convert the EOB_ACT_LAST_MATCH
-         * to EOB_ACT_END_OF_FILE.
-         */
-
-        /* Reset buffer status. */
-        yyrestart(yyin);
-
-        /*FALLTHROUGH*/
-
-      case EOB_ACT_END_OF_FILE: {
-        if (yywrap())
-          return EOF;
-
-        if (!(yy_did_buffer_switch_on_eof))
-          YY_NEW_FILE;
+	int c;
+    
+	*(yy_c_buf_p) = (yy_hold_char);
+
+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			/* This was really a NUL. */
+			*(yy_c_buf_p) = '\0';
+
+		else
+			{ /* need more input */
+			yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
+			++(yy_c_buf_p);
+
+			switch ( yy_get_next_buffer(  ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin );
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap(  ) )
+						return EOF;
+
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
 #ifdef __cplusplus
-        return yyinput();
+					return yyinput();
 #else
-        return input();
+					return input();
 #endif
-      }
+					}
 
-      case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + offset; break;
-      }
-    }
-  }
+				case EOB_ACT_CONTINUE_SCAN:
+					(yy_c_buf_p) = (yytext_ptr) + offset;
+					break;
+				}
+			}
+		}
 
-  c              = *(unsigned char *)(yy_c_buf_p); /* cast for 8-bit char's */
-  *(yy_c_buf_p)  = '\0';                           /* preserve yytext */
-  (yy_hold_char) = *++(yy_c_buf_p);
+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
+	*(yy_c_buf_p) = '\0';	/* preserve yytext */
+	(yy_hold_char) = *++(yy_c_buf_p);
 
-  /* %% [19.0] update BOL and yylineno */
+/* %% [19.0] update BOL and yylineno */
 
-  return c;
+	return c;
 }
 /* %if-c-only */
 /* %endif */
 
 /** Immediately switch to a different input stream.
  * @param input_file A readable stream.
- *
+ * 
  * @note This function does not reset the start condition to @c INITIAL .
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yyrestart(std::istream *input_file)
+    void yyFlexLexer::yyrestart( std::istream* input_file )
 /* %endif */
 {
-
-  if (!YY_CURRENT_BUFFER) {
-    yyensure_buffer_stack();
-    YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE);
-  }
-
-  yy_init_buffer(YY_CURRENT_BUFFER, input_file);
-  yy_load_buffer_state();
+    
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE );
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
+	yy_load_buffer_state(  );
 }
 
 /** Switch to a different input buffer.
  * @param new_buffer The new input buffer.
- *
+ * 
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
+    void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
 /* %endif */
 {
-
-  /* TODO. We should be able to replace this entire function body
-   * with
-   *            yypop_buffer_state();
-   *            yypush_buffer_state(new_buffer);
-   */
-  yyensure_buffer_stack();
-  if (YY_CURRENT_BUFFER == new_buffer)
-    return;
-
-  if (YY_CURRENT_BUFFER) {
-    /* Flush out information for old buffer. */
-    *(yy_c_buf_p)                        = (yy_hold_char);
-    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-  }
-
-  YY_CURRENT_BUFFER_LVALUE = new_buffer;
-  yy_load_buffer_state();
-
-  /* We don't actually know whether we did this switch during
-   * EOF (yywrap()) processing, but the only time this flag
-   * is looked at is after yywrap() is called, so it's safe
-   * to go ahead and always set it.
-   */
-  (yy_did_buffer_switch_on_eof) = 1;
+    
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack ();
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state(  );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	(yy_did_buffer_switch_on_eof) = 1;
 }
 
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_load_buffer_state()
+    void yyFlexLexer::yy_load_buffer_state()
 /* %endif */
 {
-  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-  yyin                        = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-  (yy_hold_char)              = *(yy_c_buf_p);
+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	(yy_hold_char) = *(yy_c_buf_p);
 }
 
 /** Allocate and initialize an input buffer state.
  * @param file A readable stream.
  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- *
+ * 
  * @return the allocated buffer state.
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-YY_BUFFER_STATE yyFlexLexer::yy_create_buffer(std::istream *file, int size)
+    YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
 /* %endif */
 {
-  YY_BUFFER_STATE b;
-
-  b = (YY_BUFFER_STATE)SEAMSalloc(sizeof(struct yy_buffer_state));
-  if (!b)
-    YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) SEAMSalloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
-  b->yy_buf_size = size;
+	b->yy_buf_size = size;
 
-  /* yy_ch_buf has to be 2 characters longer than the size given because
-   * we need to put in 2 end-of-buffer characters.
-   */
-  b->yy_ch_buf = (char *)SEAMSalloc(b->yy_buf_size + 2);
-  if (!b->yy_ch_buf)
-    YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) SEAMSalloc(b->yy_buf_size + 2  );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
-  b->yy_is_our_buffer = 1;
+	b->yy_is_our_buffer = 1;
 
-  yy_init_buffer(b, file);
+	yy_init_buffer( b, file );
 
-  return b;
+	return b;
 }
 
 /** Destroy the buffer.
  * @param b a buffer created with yy_create_buffer()
- *
+ * 
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_delete_buffer(YY_BUFFER_STATE b)
+    void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
 /* %endif */
 {
+    
+	if ( ! b )
+		return;
 
-  if (!b)
-    return;
-
-  if (b == YY_CURRENT_BUFFER) /* Not sure if we should pop here. */
-    YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE)0;
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
-  if (b->yy_is_our_buffer)
-    SEAMSfree((void *)b->yy_ch_buf);
+	if ( b->yy_is_our_buffer )
+		SEAMSfree((void *) b->yy_ch_buf  );
 
-  SEAMSfree((void *)b);
+	SEAMSfree((void *) b  );
 }
 
 /* Initializes or reinitializes a buffer.
@@ -2831,63 +3216,63 @@ void yyFlexLexer::yy_delete_buffer(YY_BUFFER_STATE b)
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_init_buffer(YY_BUFFER_STATE b, std::istream *file)
+    void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
 /* %endif */
 
 {
-  int oerrno = errno;
+	int oerrno = errno;
+    
+	yy_flush_buffer( b );
 
-  yy_flush_buffer(b);
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
 
-  b->yy_input_file  = file;
-  b->yy_fill_buffer = 1;
-
-  /* If b is the current buffer, then yy_init_buffer was _probably_
-   * called from yyrestart() or through yy_get_next_buffer.
-   * In that case, we don't want to reset the lineno or column.
-   */
-  if (b != YY_CURRENT_BUFFER) {
-    b->yy_bs_lineno = 1;
-    b->yy_bs_column = 0;
-  }
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
 
-  /* %if-c-only */
-  /* %endif */
-  /* %if-c++-only */
-  b->yy_is_interactive = 0;
-  /* %endif */
-  errno = oerrno;
+/* %if-c-only */
+/* %endif */
+/* %if-c++-only */
+	b->yy_is_interactive = 0;
+/* %endif */
+	errno = oerrno;
 }
 
 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- *
+ * 
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_flush_buffer(YY_BUFFER_STATE b)
+    void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
 /* %endif */
 {
-  if (!b)
-    return;
+    	if ( ! b )
+		return;
 
-  b->yy_n_chars = 0;
+	b->yy_n_chars = 0;
 
-  /* We always need two end-of-buffer characters.  The first causes
-   * a transition to the end-of-buffer state.  The second causes
-   * a jam in that state.
-   */
-  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 
-  b->yy_buf_pos = &b->yy_ch_buf[0];
+	b->yy_buf_pos = &b->yy_ch_buf[0];
 
-  b->yy_at_bol        = 1;
-  b->yy_buffer_status = YY_BUFFER_NEW;
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
 
-  if (b == YY_CURRENT_BUFFER)
-    yy_load_buffer_state();
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state(  );
 }
 
 /* %if-c-or-c++ */
@@ -2895,61 +3280,62 @@ void yyFlexLexer::yy_flush_buffer(YY_BUFFER_STATE b)
  *  the current state. This function will allocate the stack
  *  if necessary.
  *  @param new_buffer The new state.
- *
+ *  
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yypush_buffer_state(YY_BUFFER_STATE new_buffer)
+void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
 /* %endif */
 {
-  if (new_buffer == NULL)
-    return;
-
-  yyensure_buffer_stack();
-
-  /* This block is copied from yy_switch_to_buffer. */
-  if (YY_CURRENT_BUFFER) {
-    /* Flush out information for old buffer. */
-    *(yy_c_buf_p)                        = (yy_hold_char);
-    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-  }
-
-  /* Only push if top exists. Otherwise, replace top. */
-  if (YY_CURRENT_BUFFER)
-    (yy_buffer_stack_top)++;
-  YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-  /* copied from yy_switch_to_buffer. */
-  yy_load_buffer_state();
-  (yy_did_buffer_switch_on_eof) = 1;
+    	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack();
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		(yy_buffer_stack_top)++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state(  );
+	(yy_did_buffer_switch_on_eof) = 1;
 }
 /* %endif */
 
 /* %if-c-or-c++ */
 /** Removes and deletes the top of the stack, if present.
  *  The next element becomes the new top.
- *
+ *  
  */
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yypop_buffer_state(void)
+void yyFlexLexer::yypop_buffer_state (void)
 /* %endif */
 {
-  if (!YY_CURRENT_BUFFER)
-    return;
-
-  yy_delete_buffer(YY_CURRENT_BUFFER);
-  YY_CURRENT_BUFFER_LVALUE = NULL;
-  if ((yy_buffer_stack_top) > 0)
-    --(yy_buffer_stack_top);
-
-  if (YY_CURRENT_BUFFER) {
-    yy_load_buffer_state();
-    (yy_did_buffer_switch_on_eof) = 1;
-  }
+    	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER );
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if ((yy_buffer_stack_top) > 0)
+		--(yy_buffer_stack_top);
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state(  );
+		(yy_did_buffer_switch_on_eof) = 1;
+	}
 }
 /* %endif */
 
@@ -2963,43 +3349,45 @@ void yyFlexLexer::yypop_buffer_state(void)
 void yyFlexLexer::yyensure_buffer_stack(void)
 /* %endif */
 {
-  yy_size_t num_to_alloc;
-
-  if (!(yy_buffer_stack)) {
-
-    /* First allocation is just for 2 elements, since we don't know if this
-     * scanner will even need a stack. We use 2 instead of 1 to avoid an
-     * immediate realloc on the next call.
-     */
-    num_to_alloc = 1;
-    (yy_buffer_stack) =
-        (struct yy_buffer_state **)SEAMSalloc(num_to_alloc * sizeof(struct yy_buffer_state *));
-    if (!(yy_buffer_stack))
-      YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()");
-
-    memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state *));
-
-    (yy_buffer_stack_max) = num_to_alloc;
-    (yy_buffer_stack_top) = 0;
-    return;
-  }
+	yy_size_t num_to_alloc;
+    
+	if (!(yy_buffer_stack)) {
 
-  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1) {
-
-    /* Increase the buffer to prepare for a possible push. */
-    int grow_size = 8 /* arbitrary grow size */;
-
-    num_to_alloc      = (yy_buffer_stack_max) + grow_size;
-    (yy_buffer_stack) = (struct yy_buffer_state **)SEAMSrealloc(
-        (yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state *));
-    if (!(yy_buffer_stack))
-      YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()");
-
-    /* zero only the new slots.*/
-    memset((yy_buffer_stack) + (yy_buffer_stack_max), 0,
-           grow_size * sizeof(struct yy_buffer_state *));
-    (yy_buffer_stack_max) = num_to_alloc;
-  }
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+		num_to_alloc = 1;
+		(yy_buffer_stack) = (struct yy_buffer_state**)SEAMSalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+								  
+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+				
+		(yy_buffer_stack_max) = num_to_alloc;
+		(yy_buffer_stack_top) = 0;
+		return;
+	}
+
+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		int grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
+		(yy_buffer_stack) = (struct yy_buffer_state**)SEAMSrealloc
+								((yy_buffer_stack),
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+		(yy_buffer_stack_max) = num_to_alloc;
+	}
 }
 /* %endif */
 
@@ -3015,47 +3403,51 @@ void yyFlexLexer::yyensure_buffer_stack(void)
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_push_state(int new_state)
+    void yyFlexLexer::yy_push_state( int new_state )
 /* %endif */
 {
-  if ((yy_start_stack_ptr) >= (yy_start_stack_depth)) {
-    yy_size_t new_size;
+    	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
+		{
+		yy_size_t new_size;
 
-    (yy_start_stack_depth) += YY_START_STACK_INCR;
-    new_size = (yy_start_stack_depth) * sizeof(int);
+		(yy_start_stack_depth) += YY_START_STACK_INCR;
+		new_size = (yy_start_stack_depth) * sizeof( int );
 
-    if (!(yy_start_stack))
-      (yy_start_stack) = (int *)SEAMSalloc(new_size);
+		if ( ! (yy_start_stack) )
+			(yy_start_stack) = (int *) SEAMSalloc(new_size  );
 
-    else
-      (yy_start_stack) = (int *)SEAMSrealloc((void *)(yy_start_stack), new_size);
+		else
+			(yy_start_stack) = (int *) SEAMSrealloc((void *) (yy_start_stack),new_size  );
 
-    if (!(yy_start_stack))
-      YY_FATAL_ERROR("out of memory expanding start-condition stack");
-  }
+		if ( ! (yy_start_stack) )
+			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
+		}
 
-  (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
+	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
 
-  BEGIN(new_state);
+	BEGIN(new_state);
 }
 
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::yy_pop_state()
+    void yyFlexLexer::yy_pop_state()
 /* %endif */
 {
-  if (--(yy_start_stack_ptr) < 0)
-    YY_FATAL_ERROR("start-condition stack underflow");
+    	if ( --(yy_start_stack_ptr) < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
 
-  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
+	BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
 }
 
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-int yyFlexLexer::yy_top_state()
-/* %endif */ { return (yy_start_stack)[(yy_start_stack_ptr)-1]; }
+    int yyFlexLexer::yy_top_state()
+/* %endif */
+{
+    	return (yy_start_stack)[(yy_start_stack_ptr) - 1];
+}
 
 #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2
@@ -3064,27 +3456,29 @@ int yyFlexLexer::yy_top_state()
 /* %if-c-only */
 /* %endif */
 /* %if-c++-only */
-void yyFlexLexer::LexerError(yyconst char msg[])
+void yyFlexLexer::LexerError( yyconst char msg[] )
 {
-  std::cerr << msg << std::endl;
-  exit(YY_EXIT_FAILURE);
+    	std::cerr << msg << std::endl;
+	exit( YY_EXIT_FAILURE );
 }
 /* %endif */
 
 /* Redefine yyless() so it works in section 3 code. */
 
 #undef yyless
-#define yyless(n)                                                                                  \
-  do {                                                                                             \
-    /* Undo effects of setting up yytext. */                                                       \
-    int yyless_macro_arg = (n);                                                                    \
-    YY_LESS_LINENO(yyless_macro_arg);                                                              \
-    yytext[yyleng] = (yy_hold_char);                                                               \
-    (yy_c_buf_p)   = yytext + yyless_macro_arg;                                                    \
-    (yy_hold_char) = *(yy_c_buf_p);                                                                \
-    *(yy_c_buf_p)  = '\0';                                                                         \
-    yyleng         = yyless_macro_arg;                                                             \
-  } while (0)
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = (yy_hold_char); \
+		(yy_c_buf_p) = yytext + yyless_macro_arg; \
+		(yy_hold_char) = *(yy_c_buf_p); \
+		*(yy_c_buf_p) = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
 
 /* Accessor  methods (get/set functions) to struct members. */
 
@@ -3113,40 +3507,46 @@ void yyFlexLexer::LexerError(yyconst char msg[])
  */
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy(char *s1, yyconst char *s2, int n)
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 {
-  int i;
-  for (i = 0; i < n; ++i)
-    s1[i] = s2[i];
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
 }
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen(yyconst char *s)
+static int yy_flex_strlen (yyconst char * s )
 {
-  int n;
-  for (n = 0; s[n]; ++n)
-    ;
+	register int n;
+	for ( n = 0; s[n]; ++n )
+		;
 
-  return n;
+	return n;
 }
 #endif
 
-void *SEAMSalloc(yy_size_t size) { return (void *)malloc(size); }
+void *SEAMSalloc (yy_size_t  size )
+{
+	return (void *) malloc( size );
+}
 
-void *SEAMSrealloc(void *ptr, yy_size_t size)
+void *SEAMSrealloc  (void * ptr, yy_size_t  size )
 {
-  /* The cast to (char *) in the following accommodates both
-   * implementations that use char* generic pointers, and those
-   * that use void* generic pointers.  It works with the latter
-   * because both ANSI C and C++ allow castless assignment from
-   * any pointer type to void*, and deal with argument conversions
-   * as though doing an assignment.
-   */
-  return (void *)realloc((char *)ptr, size);
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return (void *) realloc( (char *) ptr, size );
 }
 
-void SEAMSfree(void *ptr) { free((char *)ptr); /* see SEAMSrealloc() for (char *) cast */ }
+void SEAMSfree (void * ptr )
+{
+	free( (char *) ptr );	/* see SEAMSrealloc() for (char *) cast */
+}
 
 /* %if-tables-serialization definitions */
 /* %define-yytables   The name for this specific scanner's tables. */
@@ -3155,15 +3555,16 @@ void SEAMSfree(void *ptr) { free((char *)ptr); /* see SEAMSrealloc() for (char *
 
 /* %ok-for-header */
 
-/* When the scanner receives an end-of-file indication from YY_INPUT, it then
- * checks the yywrap() function. If yywrap() returns false (zero), then it is
- * assumed that the function has gone ahead and set up `yyin' to point to
- * another input file, and scanning continues. If it returns true (non-zero),
- * then the scanner terminates, returning 0 to its caller. */
+    /* When the scanner receives an end-of-file indication from YY_INPUT, it then
+     * checks the yywrap() function. If yywrap() returns false (zero), then it is
+     * assumed that the function has gone ahead and set up `yyin' to point to
+     * another input file, and scanning continues. If it returns true (non-zero),
+     * then the scanner terminates, returning 0 to its caller. */
 
-namespace SEAMS {
+    namespace SEAMS
+{
 
-  Scanner::Scanner(Aprepro &aprepro_yyarg, std::istream *in, std::ostream *out)
+  Scanner::Scanner(Aprepro & aprepro_yyarg, std::istream * in, std::ostream * out)
       : SEAMSFlexLexer(in, out), aprepro(aprepro_yyarg)
   {
     aprepro.outputStream.push(out);
@@ -3201,6 +3602,8 @@ namespace SEAMS {
     // output stream.
     if (aprepro.ap_options.keep_history) {
       aprepro.add_history(history_string, buf);
+      history_string.clear();
+      hist_start = 0;
     }
 
     aprepro.outputStream.top()->write(buf, size);
@@ -3251,6 +3654,8 @@ namespace SEAMS {
   int Scanner::yywrap()
   {
     // Clear the history string.
+    history_string.clear();
+    hist_start = 0;
     curr_index = 0;
 
     // If we are using the string interactive method, we want to return to
@@ -3498,9 +3903,8 @@ namespace SEAMS {
     }
     else {
       if (aprepro.ap_options.debugging) {
-        fprintf(stderr,
-                "DEBUG SWITCH: 'case' condition = %g does not match switch condition = %g "
-                "(or case already matched) at line %d\n",
+        fprintf(stderr, "DEBUG SWITCH: 'case' condition = %g does not match switch condition = %g "
+                        "(or case already matched) at line %d\n",
                 x, switch_condition, aprepro.ap_file_list.top().lineno);
       }
 
@@ -3518,7 +3922,7 @@ namespace SEAMS {
 
     // Don't do it if the file is the one used by execute and rescan.
     if (aprepro.ap_file_list.top().name == "_string_" ||
-        aprepro.ap_file_list.top().name == "standard input") {
+	aprepro.ap_file_list.top().name == "standard input") {
       return;
     }
 
@@ -3534,6 +3938,7 @@ namespace SEAMS {
       yyerror("Stream state bad in `save_history_string` seekg");
       return;
     }
+
     // Read everything up to this point again and save it.
     auto tmp = new char[len + 1];
     yyin->read(tmp, len);
@@ -3547,10 +3952,10 @@ namespace SEAMS {
     delete[] tmp;
     hist_start = 0;
   }
-} // namespace SEAMS
+}
 
-/* This implementation of ExampleFlexLexer::yylex() is required to fill the
- * vtable of the class ExampleFlexLexer. We define the scanner's main yylex
+/* This implementation of SEAMSFlexLexer::yylex() is required to fill the
+ * vtable of the class SEAMSFlexLexer. We define the scanner's main yylex
  * function via YY_DECL to reside in the Scanner class instead. */
 
 #ifdef yylex
@@ -3558,7 +3963,7 @@ namespace SEAMS {
 #endif
 int SEAMSFlexLexer::yylex()
 {
-  std::cerr << "in ExampleFlexLexer::yylex() !" << '\n';
+  std::cerr << "in SEAMSFlexLexer::yylex() !" << '\n';
   return 0;
 }
 
@@ -3569,3 +3974,4 @@ int SEAMSFlexLexer::yylex()
  * then the scanner terminates, returning 0 to its caller. */
 
 int SEAMSFlexLexer::yywrap() { return 1; }
+
diff --git a/packages/seacas/libraries/aprepro_lib/aprepro.ll b/packages/seacas/libraries/aprepro_lib/aprepro.ll
index 450c11ff603e..381949b7ab6a 100644
--- a/packages/seacas/libraries/aprepro_lib/aprepro.ll
+++ b/packages/seacas/libraries/aprepro_lib/aprepro.ll
@@ -345,6 +345,10 @@ integer {D}+({E})?
   BEGIN(INITIAL);
   switch_active = false;
   switch_skip_to_endcase = false;
+  suppress_nl = false;
+  if (aprepro.ap_options.debugging)
+    fprintf (stderr, "DEBUG SWITCH: 'endswitch' at line %d\n",
+	     aprepro.ap_file_list.top().lineno);
 }
 
 <END_CASE_SKIP>.*"\n" {  aprepro.ap_file_list.top().lineno++; }
@@ -355,6 +359,7 @@ integer {D}+({E})?
     yyerror("endswitch statement found without matching switch.");
   }
   switch_active = false;
+  switch_skip_to_endcase = false;
 }
 
 <INITIAL>{
@@ -523,8 +528,10 @@ integer {D}+({E})?
     }
     else {
       if (if_state[if_lvl] == IF_SKIP ||
-          if_state[if_lvl] == INITIAL)
+          if_state[if_lvl] == INITIAL) {
             BEGIN(INITIAL);
+	    suppress_nl = false;
+      }
                            /* If neither is true, this is a nested
                               if that should be skipped */
       if (aprepro.ap_options.debugging)
diff --git a/packages/seacas/libraries/aprepro_lib/test_standard.out b/packages/seacas/libraries/aprepro_lib/test_standard.out
index d96c356e0fd3..87b7dfadc848 100644
--- a/packages/seacas/libraries/aprepro_lib/test_standard.out
+++ b/packages/seacas/libraries/aprepro_lib/test_standard.out
@@ -82,6 +82,7 @@ $ Test switch
 This should echo
 3.141592654
 
+
 This should be equal to PI --  3.141592654
 $ Test int and [] (shortcut for int)
 5	-5

From b863809eee953b614d43facaa2d4d28d6c5a8ad4 Mon Sep 17 00:00:00 2001
From: Christian Glusa <caglusa@sandia.gov>
Date: Thu, 21 Nov 2019 11:38:44 -0700
Subject: [PATCH 18/21] Teuchos StackedTimer: add option to print rank with
 min/max time

---
 .../teuchos/comm/src/Teuchos_StackedTimer.cpp | 56 ++++++++++++++++++-
 .../teuchos/comm/src/Teuchos_StackedTimer.hpp |  8 ++-
 2 files changed, 62 insertions(+), 2 deletions(-)

diff --git a/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp b/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp
index 52f6572ee622..ae03e3b56a50 100644
--- a/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp
+++ b/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp
@@ -94,13 +94,18 @@ StackedTimer::collectRemoteData(Teuchos::RCP<const Teuchos::Comm<int> > comm, co
   updates_.resize(num_names);
   active_.resize(num_names);
 
-  if (options.output_minmax || options.output_histogram) {
+  if (options.output_minmax || options.output_histogram || options.output_proc_minmax) {
     min_.resize(num_names);
     max_.resize(num_names);
     if ( options.output_minmax )
       sum_sq_.resize(num_names);
   }
 
+  if (options.output_proc_minmax) {
+    procmin_.resize(num_names);
+    procmax_.resize(num_names);
+  }
+
 
   if (options.output_histogram ) {
     hist_.resize(options.num_histogram);
@@ -139,6 +144,23 @@ StackedTimer::collectRemoteData(Teuchos::RCP<const Teuchos::Comm<int> > comm, co
   if (min_.size()) {
     reduceAll(*comm, REDUCE_MIN, num_names, time.getRawPtr(), min_.getRawPtr());
     reduceAll(*comm, REDUCE_MAX, num_names, time.getRawPtr(), max_.getRawPtr());
+    if (procmin_.size()) {
+      Array<int> procmin(num_names);
+      Array<int> procmax(num_names);
+      int commRank = comm->getRank();
+      for (int i=0;i<num_names; ++i) {
+        if (used[i] && (min_[i]==time[i]))
+          procmin[i] = commRank;
+        else
+          procmin[i] = -1;
+        if (used[i] && (max_[i]==time[i]))
+          procmax[i] = commRank;
+        else
+          procmax[i] = -1;
+      }
+      reduceAll(*comm, REDUCE_MAX, num_names, procmin.getRawPtr(), procmin_.getRawPtr());
+      reduceAll(*comm, REDUCE_MAX, num_names, procmax.getRawPtr(), procmax_.getRawPtr());
+    }
   }
 
   if (options.output_histogram) {
@@ -255,6 +277,20 @@ StackedTimer::computeColumnWidthsForAligment(std::string prefix,
           os << "}";
         alignments_.max_ = std::max(alignments_.max_,os.str().size());
       }
+      if (procmin_.size()) {
+        std::ostringstream os;
+        os << ", proc min=" << procmin_[i];
+        if (active_[i] <= 1)
+          os << "}";
+        alignments_.procmin_ = std::min(alignments_.procmin_,os.str().size());
+      }
+      if (procmax_.size()) {
+        std::ostringstream os;
+        os << ", proc max=" << procmax_[i];
+        if (active_[i] <= 1)
+          os << "}";
+        alignments_.procmax_ = std::max(alignments_.procmax_,os.str().size());
+      }
       if (active_[i]>1) {
         std::ostringstream os;
         os << ", std dev=" << sqrt(std::max<double>(sum_sq_[i]-sum_[i]*sum_[i]/active_[i],0.0)/(active_[i]-1));
@@ -395,6 +431,24 @@ StackedTimer::printLevel (std::string prefix, int print_level, std::ostream &os,
           os << std::left << std::setw(alignments_.max_);
         os << tmp.str();
       }
+      if (procmin_.size()) {
+        std::ostringstream tmp;
+        tmp <<", proc min="<<procmin_[i];
+        if (active_[i] <= 1)
+          tmp << "}";
+        if (options.align_columns)
+          os << std::left << std::setw(alignments_.procmin_);
+        os << tmp.str();
+      }
+      if (procmax_.size()) {
+        std::ostringstream tmp;
+        tmp <<", proc max="<<procmax_[i];
+        if (active_[i] <= 1)
+          tmp << "}";
+        if (options.align_columns)
+          os << std::left << std::setw(alignments_.procmax_);
+        os << tmp.str();
+      }
       if (active_[i]>1) {
         std::ostringstream tmp;
         tmp << ", std dev="<<sqrt(std::max<double>(sum_sq_[i]-sum_[i]*sum_[i]/active_[i],0.0)/(active_[i]-1));
diff --git a/packages/teuchos/comm/src/Teuchos_StackedTimer.hpp b/packages/teuchos/comm/src/Teuchos_StackedTimer.hpp
index e33c445b58bf..2a80ac0bc293 100644
--- a/packages/teuchos/comm/src/Teuchos_StackedTimer.hpp
+++ b/packages/teuchos/comm/src/Teuchos_StackedTimer.hpp
@@ -589,13 +589,14 @@ class StackedTimer
    */
   struct OutputOptions {
     OutputOptions() : output_fraction(false), output_total_updates(false), output_histogram(false),
-                      output_minmax(false), num_histogram(10), max_levels(INT_MAX),
+                      output_minmax(false), output_proc_minmax(false), num_histogram(10), max_levels(INT_MAX),
                       print_warnings(true), align_columns(false), print_names_before_values(true),
                       drop_time(-1.0) {}
     bool output_fraction;
     bool output_total_updates;
     bool output_histogram;
     bool output_minmax;
+    bool output_proc_minmax;
     int num_histogram;
     int max_levels;
     bool print_warnings;
@@ -627,6 +628,8 @@ class StackedTimer
   Array<std::string> flat_names_;
   Array<double> min_;
   Array<double> max_;
+  Array<int> procmin_;
+  Array<int> procmax_;
   Array<double> sum_;
   Array<double> sum_sq_;
   Array<Array<int>> hist_;
@@ -643,6 +646,8 @@ class StackedTimer
     std::string::size_type total_updates_;
     std::string::size_type min_;
     std::string::size_type max_;
+    std::string::size_type procmin_;
+    std::string::size_type procmax_;
     std::string::size_type stddev_;
     std::string::size_type histogram_;
     AlignmentWidths() :
@@ -653,6 +658,7 @@ class StackedTimer
       total_updates_(0),
       min_(0),
       max_(0),
+      procmax_(0),
       stddev_(0),
       histogram_(0){}
   } alignments_;

From 126fe7363f55e2a980748a65e2f252fd9ec9535f Mon Sep 17 00:00:00 2001
From: Christian Glusa <caglusa@sandia.gov>
Date: Thu, 21 Nov 2019 11:39:26 -0700
Subject: [PATCH 19/21] Teuchos StackedTimer: Print min time over all ranks
 that are active only

---
 packages/teuchos/comm/src/Teuchos_StackedTimer.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp b/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp
index ae03e3b56a50..fa823a7312e0 100644
--- a/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp
+++ b/packages/teuchos/comm/src/Teuchos_StackedTimer.cpp
@@ -142,8 +142,14 @@ StackedTimer::collectRemoteData(Teuchos::RCP<const Teuchos::Comm<int> > comm, co
   reduce(used.getRawPtr(), active_.getRawPtr(), num_names, REDUCE_SUM, 0, *comm);
 
   if (min_.size()) {
-    reduceAll(*comm, REDUCE_MIN, num_names, time.getRawPtr(), min_.getRawPtr());
     reduceAll(*comm, REDUCE_MAX, num_names, time.getRawPtr(), max_.getRawPtr());
+    for (int i=0;i<num_names;++i)
+      if (!used[i])
+        time[i] = max_[i];
+    reduceAll(*comm, REDUCE_MIN, num_names, time.getRawPtr(), min_.getRawPtr());
+    for (int i=0;i<num_names;++i)
+      if (!used[i])
+        time[i] = 0.;
     if (procmin_.size()) {
       Array<int> procmin(num_names);
       Array<int> procmax(num_names);

From 06b1fec3ae657fc826441fe394c2cc07a538de17 Mon Sep 17 00:00:00 2001
From: Christian Glusa <caglusa@sandia.gov>
Date: Thu, 21 Nov 2019 14:06:04 -0700
Subject: [PATCH 20/21] Teuchos StackedTimer: add unit test for 'proc_minmax'

---
 .../comm/test/StackedTimer/stacked_timer.cpp  | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/packages/teuchos/comm/test/StackedTimer/stacked_timer.cpp b/packages/teuchos/comm/test/StackedTimer/stacked_timer.cpp
index 4accf0b2db84..cf8b2c8b9747 100644
--- a/packages/teuchos/comm/test/StackedTimer/stacked_timer.cpp
+++ b/packages/teuchos/comm/test/StackedTimer/stacked_timer.cpp
@@ -438,6 +438,43 @@ TEUCHOS_UNIT_TEST(StackedTimer, drop_time)
   }
 }
 
+TEUCHOS_UNIT_TEST(StackedTimer, proc_minmax)
+{
+
+  Teuchos::StackedTimer timer("L0");
+  timer.stopBaseTimer();
+
+  const Teuchos::RCP<const Teuchos::Comm<int>> comm = Teuchos::DefaultComm<int>::getComm();
+  if (comm->getSize() < 2)
+    return;
+  const int myRank = Teuchos::rank(*comm);
+
+  if (myRank == 0)
+    const_cast<Teuchos::BaseTimer*>(timer.findBaseTimer("L0"))->setAccumulatedTime(1.0);
+  else if (myRank == 1)
+    const_cast<Teuchos::BaseTimer*>(timer.findBaseTimer("L0"))->setAccumulatedTime(5.0);
+  else
+    const_cast<Teuchos::BaseTimer*>(timer.findBaseTimer("L0"))->setAccumulatedTime(2.0);
+
+  Teuchos::StackedTimer::OutputOptions options;
+
+  out << "\n### Printing default report ###" << std::endl;
+  options.output_minmax=true;
+  options.output_proc_minmax=true;
+  options.output_histogram=true;
+  options.num_histogram=3;
+  options.output_fraction=true;
+  timer.report(out, comm, options);
+  {
+    std::ostringstream os;
+    timer.report(os, comm, options);
+    if (myRank == 0) {
+      TEST_ASSERT(os.str().find("proc min=0") != std::string::npos);
+      TEST_ASSERT(os.str().find("proc max=1") != std::string::npos);
+    }
+  }
+}
+
 
 // Overlapping timers are not allowed in a StackedTimer, but are in
 // TimeMonitor. Since StackedTimer is automatically used in

From e1190ac2a355fd1e1a88c63d7fd38099d8b12b0e Mon Sep 17 00:00:00 2001
From: Luc Berger-Vergiat <lberge@sandia.gov>
Date: Thu, 21 Nov 2019 16:29:57 -0700
Subject: [PATCH 21/21] MueLu: fixing the count of aggregated nodes in
 refactored Phase2a of aggregation, see #6325

1) A piece of logic is wrong in the algorithms that counts
how many nodes have been aggregated in Phase2a of aggregation.
This commit fixes that by individually counting every node
that is being aggregated instead of counting all the nodes in
a newly formed aggregate, at once.

2) Currently if a tentative aggregate becomes larger than maxNodesPerAggregate
it is completely ignored. Now a partial aggregate will be formed instead.
---
 ...AggregationPhase2aAlgorithm_kokkos_def.hpp | 29 +++++++++++++------
 .../interface/ParameterListInterpreter.cpp    | 10 +++++++
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase2aAlgorithm_kokkos_def.hpp b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase2aAlgorithm_kokkos_def.hpp
index 7901bd4806c1..8057204f25ce 100644
--- a/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase2aAlgorithm_kokkos_def.hpp
+++ b/packages/muelu/src/Graph/UncoupledAggregation/MueLu_AggregationPhase2aAlgorithm_kokkos_def.hpp
@@ -136,14 +136,20 @@ namespace MueLu {
 
                                   // Loop over neighbors to count how many nodes could join
                                   // the new aggregate
+                                  // Note on 2019-11-22, LBV:
+                                  // The rootCandidate is not taken into account and in fact
+                                  // not aggregatesd later on. To change that we want to
+                                  // modify:
+                                  // if(aggSize < maxNodesPerAggregate)
+                                  // to:
+                                  // if(aggSize < maxNodesPerAggregate - 1)
                                   LO numNeighbors = 0;
                                   for(int j = 0; j < neighbors.length; ++j) {
                                     LO neigh = neighbors(j);
                                     if(neigh != rootCandidate) {
                                       if(graph.isLocalNeighborVertex(neigh) &&
-                                         aggStat(neigh) == READY &&
-                                         aggSize < maxNodesPerAggregate) {
-                                        // aggList(aggSize) = neigh;
+                                         (aggStat(neigh) == READY) &&
+                                         (aggSize < maxNodesPerAggregate)) {
                                         ++aggSize;
                                       }
                                       ++numNeighbors;
@@ -152,6 +158,8 @@ namespace MueLu {
 
                                   // If a sufficient number of nodes can join the new aggregate
                                   // then we actually create the aggregate.
+                                  // Note on 2019-11-22, LBV:
+                                  // Same changes as described in the note above could be applied
                                   if(aggSize > minNodesPerAggregate &&
                                      aggSize > factor*numNeighbors) {
 
@@ -159,19 +167,22 @@ namespace MueLu {
                                     LO aggIndex = Kokkos::
                                       atomic_fetch_add(&numLocalAggregates(), 1);
 
-                                    for(int j = 0; j < neighbors.length; ++j) {
-                                      LO neigh = neighbors(j);
+                                    LO numAggregated = 0;
+                                    for(int neighIdx = 0; neighIdx < neighbors.length; ++neighIdx) {
+                                      LO neigh = neighbors(neighIdx);
                                       if(neigh != rootCandidate) {
                                         if(graph.isLocalNeighborVertex(neigh) &&
-                                           aggStat(neigh) == READY &&
-                                           aggSize < maxNodesPerAggregate) {
-                                          aggStat(neigh)   = AGGREGATED;
+                                           (aggStat(neigh) == READY) &&
+                                           (numAggregated < aggSize)) {
+                                          aggStat(neigh)         = AGGREGATED;
                                           vertex2AggId(neigh, 0) = aggIndex;
                                           procWinner(neigh, 0)   = myRank;
+
+                                          ++numAggregated;
+                                          --lNumNonAggregatedNodes;
                                         }
                                       }
                                     }
-                                    lNumNonAggregatedNodes -= aggSize;
                                   }
                                 }
                               }, tmpNumNonAggregatedNodes);
diff --git a/packages/muelu/test/interface/ParameterListInterpreter.cpp b/packages/muelu/test/interface/ParameterListInterpreter.cpp
index e7ad61ba3ed8..05429778768a 100644
--- a/packages/muelu/test/interface/ParameterListInterpreter.cpp
+++ b/packages/muelu/test/interface/ParameterListInterpreter.cpp
@@ -407,6 +407,16 @@ int main_(Teuchos::CommandLineProcessor &clp, Xpetra::UnderlyingLib& lib, int ar
           stringToReplace = "Smoother complexity = " + floatRegex;
           replacementString = "Smoother complexity = <ignored>";
           run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
+
+          // Finally ignore the Chebyshev eigen value ratio which varies with aggregation
+          stringToReplace = "chebyshev: ratio eigenvalue = " + floatRegex;
+          replacementString = "chebyshev: ratio eigenvalue = <ignored>";
+          run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
+
+          // as well as the alpha paramter it sets
+          stringToReplace = "lambdaMax = <ignored>, alpha: " + floatRegex + ", lambdaMin = <ignored>,";
+          replacementString = "lambdaMax = <ignored>, alpha: <ignored>, lambdaMin = <ignored>,";
+          run_sed("'s/" + stringToReplace + "/" + replacementString + "/'", baseFile);
         }
 
         // Run comparison (ignoring whitespaces)