diff --git a/src/tinyformat.h b/src/tinyformat.h
--- a/src/tinyformat.h
+++ b/src/tinyformat.h
@@ -93,7 +93,8 @@
 // this by storing the argument list in a type-opaque way.  Continuing the
 // example from above, we construct a FormatList using makeFormatList():
 //
-//   FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour, min);
+//   FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour,
+//   min);
 //
 // The format list can now be passed into any non-template function and used
 // via a call to the vformat() function:
@@ -111,7 +112,6 @@
 // User defined types: Uses operator<< for user defined types by default.
 // Overload formatValue() for more control.
 
-
 #ifndef TINYFORMAT_H_INCLUDED
 #define TINYFORMAT_H_INCLUDED
 
@@ -129,7 +129,6 @@
 // general.  If you don't define this, C++11 support is autodetected below.
 #define TINYFORMAT_USE_VARIADIC_TEMPLATES
 
-
 //------------------------------------------------------------------------------
 // Implementation details.
 #include <algorithm>
@@ -139,27 +138,28 @@
 #include <stdexcept>
 
 #ifndef TINYFORMAT_ERROR
-#   define TINYFORMAT_ERROR(reason) assert(0 && reason)
+#define TINYFORMAT_ERROR(reason) assert(0 && reason)
 #endif
 
-#if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
-#   ifdef __GXX_EXPERIMENTAL_CXX0X__
-#       define TINYFORMAT_USE_VARIADIC_TEMPLATES
-#   endif
+#if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) &&                             \
+    !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#define TINYFORMAT_USE_VARIADIC_TEMPLATES
+#endif
 #endif
 
 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
 //  std::showpos is broken on old libstdc++ as provided with OSX.  See
 //  http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
-#   define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
+#define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 #endif
 
 #ifdef __APPLE__
 // Workaround OSX linker warning: xcode uses different default symbol
 // visibilities for static libs vs executables (see issue #25)
-#   define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
+#define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
 #else
-#   define TINYFORMAT_HIDDEN
+#define TINYFORMAT_HIDDEN
 #endif
 
 namespace tinyformat {
@@ -168,73 +168,71 @@
 namespace detail {
 
 // Test whether type T1 is convertible to type T2
-template <typename T1, typename T2>
-struct is_convertible
-{
-    private:
-        // two types of different size
-        struct fail { char dummy[2]; };
-        struct succeed { char dummy; };
-        // Try to convert a T1 to a T2 by plugging into tryConvert
-        static fail tryConvert(...);
-        static succeed tryConvert(const T2&);
-        static const T1& makeT1();
-    public:
-#       ifdef _MSC_VER
-        // Disable spurious loss of precision warnings in tryConvert(makeT1())
-#       pragma warning(push)
-#       pragma warning(disable:4244)
-#       pragma warning(disable:4267)
-#       endif
-        // Standard trick: the (...) version of tryConvert will be chosen from
-        // the overload set only if the version taking a T2 doesn't match.
-        // Then we compare the sizes of the return types to check which
-        // function matched.  Very neat, in a disgusting kind of way :)
-        static const bool value =
-            sizeof(tryConvert(makeT1())) == sizeof(succeed);
-#       ifdef _MSC_VER
-#       pragma warning(pop)
-#       endif
+template <typename T1, typename T2> struct is_convertible {
+private:
+    // two types of different size
+    struct fail {
+        char dummy[2];
+    };
+    struct succeed {
+        char dummy;
+    };
+    // Try to convert a T1 to a T2 by plugging into tryConvert
+    static fail tryConvert(...);
+    static succeed tryConvert(const T2 &);
+    static const T1 &makeT1();
+
+public:
+#ifdef _MSC_VER
+// Disable spurious loss of precision warnings in tryConvert(makeT1())
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4267)
+#endif
+    // Standard trick: the (...) version of tryConvert will be chosen from
+    // the overload set only if the version taking a T2 doesn't match.
+    // Then we compare the sizes of the return types to check which
+    // function matched.  Very neat, in a disgusting kind of way :)
+    static const bool value = sizeof(tryConvert(makeT1())) == sizeof(succeed);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 };
 
-
 // Detect when a type is not a wchar_t string
-template<typename T> struct is_wchar { typedef int tinyformat_wchar_is_not_supported; };
-template<> struct is_wchar<wchar_t*> {};
-template<> struct is_wchar<const wchar_t*> {};
-template<int n> struct is_wchar<const wchar_t[n]> {};
-template<int n> struct is_wchar<wchar_t[n]> {};
-
+template <typename T> struct is_wchar {
+    typedef int tinyformat_wchar_is_not_supported;
+};
+template <> struct is_wchar<wchar_t *> {};
+template <> struct is_wchar<const wchar_t *> {};
+template <int n> struct is_wchar<const wchar_t[n]> {};
+template <int n> struct is_wchar<wchar_t[n]> {};
 
 // Format the value by casting to type fmtT.  This default implementation
 // should never be called.
-template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
-struct formatValueAsType
-{
-    static void invoke(std::ostream& /*out*/, const T& /*value*/) { assert(0); }
+template <typename T, typename fmtT,
+          bool convertible = is_convertible<T, fmtT>::value>
+struct formatValueAsType {
+    static void invoke(std::ostream & /*out*/, const T & /*value*/) {
+        assert(0);
+    }
 };
 // Specialized version for types that can actually be converted to fmtT, as
 // indicated by the "convertible" template parameter.
-template<typename T, typename fmtT>
-struct formatValueAsType<T,fmtT,true>
-{
-    static void invoke(std::ostream& out, const T& value)
-        { out << static_cast<fmtT>(value); }
+template <typename T, typename fmtT> struct formatValueAsType<T, fmtT, true> {
+    static void invoke(std::ostream &out, const T &value) {
+        out << static_cast<fmtT>(value);
+    }
 };
 
 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
-template<typename T, bool convertible = is_convertible<T, int>::value>
-struct formatZeroIntegerWorkaround
-{
-    static bool invoke(std::ostream& /**/, const T& /**/) { return false; }
+template <typename T, bool convertible = is_convertible<T, int>::value>
+struct formatZeroIntegerWorkaround {
+    static bool invoke(std::ostream & /**/, const T & /**/) { return false; }
 };
-template<typename T>
-struct formatZeroIntegerWorkaround<T,true>
-{
-    static bool invoke(std::ostream& out, const T& value)
-    {
-        if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos)
-        {
+template <typename T> struct formatZeroIntegerWorkaround<T, true> {
+    static bool invoke(std::ostream &out, const T &value) {
+        if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos) {
             out << "+0";
             return true;
         }
@@ -245,40 +243,35 @@
 
 // Convert an arbitrary type to integer.  The version with convertible=false
 // throws an error.
-template<typename T, bool convertible = is_convertible<T,int>::value>
-struct convertToInt
-{
-    static int invoke(const T& /*value*/)
-    {
+template <typename T, bool convertible = is_convertible<T, int>::value>
+struct convertToInt {
+    static int invoke(const T & /*value*/) {
         TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
                          "integer for use as variable width or precision");
         return 0;
     }
 };
 // Specialization for convertToInt when conversion is possible
-template<typename T>
-struct convertToInt<T,true>
-{
-    static int invoke(const T& value) { return static_cast<int>(value); }
+template <typename T> struct convertToInt<T, true> {
+    static int invoke(const T &value) { return static_cast<int>(value); }
 };
 
 // Format at most ntrunc characters to the given stream.
-template<typename T>
-inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
-{
+template <typename T>
+inline void formatTruncated(std::ostream &out, const T &value, int ntrunc) {
     std::ostringstream tmp;
     tmp << value;
     std::string result = tmp.str();
-    out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
-}
-#define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type)       \
-inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \
-{                                                           \
-    std::streamsize len = 0;                                \
-    while(len < ntrunc && value[len] != 0)                  \
-        ++len;                                              \
-    out.write(value, len);                                  \
+    out.write(result.c_str(),
+              (std::min)(ntrunc, static_cast<int>(result.size())));
 }
+#define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type)                          \
+    inline void formatTruncated(std::ostream &out, type *value, int ntrunc) {  \
+        std::streamsize len = 0;                                               \
+        while (len < ntrunc && value[len] != 0)                                \
+            ++len;                                                             \
+        out.write(value, len);                                                 \
+    }
 // Overload for const char* and char*.  Could overload for signed & unsigned
 // char too, but these are technically unneeded for printf compatibility.
 TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char)
@@ -287,12 +280,10 @@
 
 } // namespace detail
 
-
 //------------------------------------------------------------------------------
 // Variable formatting functions.  May be overridden for user-defined types if
 // desired.
 
-
 /// Format a value into a stream, delegating to operator<< by default.
 ///
 /// Users may override this for their own types.  When this function is called,
@@ -304,70 +295,73 @@
 /// By default, formatValue() uses the usual stream insertion operator
 /// operator<< to format the type T, with special cases for the %c and %p
 /// conversions.
-template<typename T>
-inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
-                        const char* fmtEnd, int ntrunc, const T& value)
-{
+template <typename T>
+inline void formatValue(std::ostream &out, const char * /*fmtBegin*/,
+                        const char *fmtEnd, int ntrunc, const T &value) {
 #ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
     // Since we don't support printing of wchar_t using "%ls", make it fail at
     // compile time in preference to printing as a void* at runtime.
-    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
-    (void) DummyType(); // avoid unused type warning with gcc-4.8
+    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported
+        DummyType;
+    (void)DummyType(); // avoid unused type warning with gcc-4.8
 #endif
     // The mess here is to support the %c and %p conversions: if these
     // conversions are active we try to convert the type to a char or const
     // void* respectively and format that instead of the value itself.  For the
     // %p conversion it's important to avoid dereferencing the pointer, which
     // could otherwise lead to a crash when printing a dangling (const char*).
-    const bool canConvertToChar = detail::is_convertible<T,char>::value;
-    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
-    if(canConvertToChar && *(fmtEnd-1) == 'c')
+    const bool canConvertToChar = detail::is_convertible<T, char>::value;
+    const bool canConvertToVoidPtr =
+        detail::is_convertible<T, const void *>::value;
+    if (canConvertToChar && *(fmtEnd - 1) == 'c')
         detail::formatValueAsType<T, char>::invoke(out, value);
-    else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
-        detail::formatValueAsType<T, const void*>::invoke(out, value);
+    else if (canConvertToVoidPtr && *(fmtEnd - 1) == 'p')
+        detail::formatValueAsType<T, const void *>::invoke(out, value);
 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
-    else if(detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
+    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/
+        ;
 #endif
-    else if(ntrunc >= 0)
-    {
+    else if (ntrunc >= 0) {
         // Take care not to overread C strings in truncating conversions like
         // "%.4s" where at most 4 characters may be read.
         detail::formatTruncated(out, value, ntrunc);
-    }
-    else
+    } else
         out << value;
 }
 
-
 // Overloaded version for char types to support printing as an integer
-#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType)                  \
-inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,  \
-                        const char* fmtEnd, int /**/, charType value) \
-{                                                                     \
-    switch(*(fmtEnd-1))                                               \
-    {                                                                 \
-        case 'u': case 'd': case 'i': case 'o': case 'X': case 'x':   \
-            out << static_cast<int>(value); break;                    \
-        default:                                                      \
-            out << value;                   break;                    \
-    }                                                                 \
-}
+#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType)                           \
+    inline void formatValue(std::ostream &out, const char * /*fmtBegin*/,      \
+                            const char *fmtEnd, int /**/, charType value) {    \
+        switch (*(fmtEnd - 1)) {                                               \
+            case 'u':                                                          \
+            case 'd':                                                          \
+            case 'i':                                                          \
+            case 'o':                                                          \
+            case 'X':                                                          \
+            case 'x':                                                          \
+                out << static_cast<int>(value);                                \
+                break;                                                         \
+            default:                                                           \
+                out << value;                                                  \
+                break;                                                         \
+        }                                                                      \
+    }
 // per 3.9.1: char, signed char and unsigned char are all distinct types
 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
 #undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR
 
-
 //------------------------------------------------------------------------------
 // Tools for emulating variadic templates in C++98.  The basic idea here is
 // stolen from the boost preprocessor metaprogramming library and cut down to
 // be just general enough for what we need.
 
-#define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n
-#define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n
-#define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n
-#define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n
+#define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_##n
+#define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_##n
+#define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_##n
+#define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_##n
 
 // To keep it as transparent as possible, the macros below have been generated
 // using python via the excellent cog.py code generation script.  This avoids
@@ -410,34 +404,90 @@
 #define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
 #define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
 #define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
-#define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6
-#define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7
-#define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8
-#define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9
-#define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10
-#define TINYFORMAT_ARGTYPES_11 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11
-#define TINYFORMAT_ARGTYPES_12 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12
-#define TINYFORMAT_ARGTYPES_13 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13
-#define TINYFORMAT_ARGTYPES_14 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14
-#define TINYFORMAT_ARGTYPES_15 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15
-#define TINYFORMAT_ARGTYPES_16 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16
-
-#define TINYFORMAT_VARARGS_1 const T1& v1
-#define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2
-#define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3
-#define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4
-#define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5
-#define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6
-#define TINYFORMAT_VARARGS_7 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7
-#define TINYFORMAT_VARARGS_8 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8
-#define TINYFORMAT_VARARGS_9 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9
-#define TINYFORMAT_VARARGS_10 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10
-#define TINYFORMAT_VARARGS_11 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11
-#define TINYFORMAT_VARARGS_12 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12
-#define TINYFORMAT_VARARGS_13 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13
-#define TINYFORMAT_VARARGS_14 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14
-#define TINYFORMAT_VARARGS_15 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15
-#define TINYFORMAT_VARARGS_16 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16
+#define TINYFORMAT_ARGTYPES_6                                                  \
+    class T1, class T2, class T3, class T4, class T5, class T6
+#define TINYFORMAT_ARGTYPES_7                                                  \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7
+#define TINYFORMAT_ARGTYPES_8                                                  \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8
+#define TINYFORMAT_ARGTYPES_9                                                  \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9
+#define TINYFORMAT_ARGTYPES_10                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10
+#define TINYFORMAT_ARGTYPES_11                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10, class T11
+#define TINYFORMAT_ARGTYPES_12                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10, class T11, class T12
+#define TINYFORMAT_ARGTYPES_13                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10, class T11, class T12, class T13
+#define TINYFORMAT_ARGTYPES_14                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10, class T11, class T12, class T13,        \
+        class T14
+#define TINYFORMAT_ARGTYPES_15                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10, class T11, class T12, class T13,        \
+        class T14, class T15
+#define TINYFORMAT_ARGTYPES_16                                                 \
+    class T1, class T2, class T3, class T4, class T5, class T6, class T7,      \
+        class T8, class T9, class T10, class T11, class T12, class T13,        \
+        class T14, class T15, class T16
+
+#define TINYFORMAT_VARARGS_1 const T1 &v1
+#define TINYFORMAT_VARARGS_2 const T1 &v1, const T2 &v2
+#define TINYFORMAT_VARARGS_3 const T1 &v1, const T2 &v2, const T3 &v3
+#define TINYFORMAT_VARARGS_4                                                   \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4
+#define TINYFORMAT_VARARGS_5                                                   \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5
+#define TINYFORMAT_VARARGS_6                                                   \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6
+#define TINYFORMAT_VARARGS_7                                                   \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7
+#define TINYFORMAT_VARARGS_8                                                   \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8
+#define TINYFORMAT_VARARGS_9                                                   \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9
+#define TINYFORMAT_VARARGS_10                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, const T10 &v10
+#define TINYFORMAT_VARARGS_11                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
+        const T10 &v10, const T11 &v11
+#define TINYFORMAT_VARARGS_12                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
+        const T10 &v10, const T11 &v11, const T12 &v12
+#define TINYFORMAT_VARARGS_13                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
+        const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13
+#define TINYFORMAT_VARARGS_14                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
+        const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13,        \
+        const T14 &v14
+#define TINYFORMAT_VARARGS_15                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
+        const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13,        \
+        const T14 &v14, const T15 &v15
+#define TINYFORMAT_VARARGS_16                                                  \
+    const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5,      \
+        const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9,                \
+        const T10 &v10, const T11 &v11, const T12 &v12, const T13 &v13,        \
+        const T14 &v14, const T15 &v15, const T16 &v16
 
 #define TINYFORMAT_PASSARGS_1 v1
 #define TINYFORMAT_PASSARGS_2 v1, v2
@@ -451,10 +501,14 @@
 #define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
 #define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 #define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
-#define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
-#define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
-#define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
-#define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
+#define TINYFORMAT_PASSARGS_13                                                 \
+    v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
+#define TINYFORMAT_PASSARGS_14                                                 \
+    v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
+#define TINYFORMAT_PASSARGS_15                                                 \
+    v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
+#define TINYFORMAT_PASSARGS_16                                                 \
+    v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 
 #define TINYFORMAT_PASSARGS_TAIL_1
 #define TINYFORMAT_PASSARGS_TAIL_2 , v2
@@ -467,75 +521,70 @@
 #define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
 #define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
 #define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
-#define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
-#define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
-#define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
-#define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
-#define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
-
-#define TINYFORMAT_FOREACH_ARGNUM(m) \
-    m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) m(15) m(16)
+#define TINYFORMAT_PASSARGS_TAIL_12                                            \
+    , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
+#define TINYFORMAT_PASSARGS_TAIL_13                                            \
+    , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
+#define TINYFORMAT_PASSARGS_TAIL_14                                            \
+    , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
+#define TINYFORMAT_PASSARGS_TAIL_15                                            \
+    , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
+#define TINYFORMAT_PASSARGS_TAIL_16                                            \
+    , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
+
+#define TINYFORMAT_FOREACH_ARGNUM(m)                                           \
+    m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) \
+        m(15) m(16)
 //[[[end]]]
 
-
-
 namespace detail {
 
 // Type-opaque holder for an argument to format(), with associated actions on
 // the type held as explicit function pointers.  This allows FormatArg's for
 // each argument to be allocated as a homogenous array inside FormatList
 // whereas a naive implementation based on inheritance does not.
-class FormatArg
-{
-    public:
-        FormatArg() {}
-
-        template<typename T>
-        FormatArg(const T& value)
-            : m_value(static_cast<const void*>(&value)),
-            m_formatImpl(&formatImpl<T>),
-            m_toIntImpl(&toIntImpl<T>)
-        { }
-
-        void format(std::ostream& out, const char* fmtBegin,
-                    const char* fmtEnd, int ntrunc) const
-        {
-            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
-        }
+class FormatArg {
+public:
+    FormatArg() {}
+
+    template <typename T>
+    FormatArg(const T &value)
+        : m_value(static_cast<const void *>(&value)),
+          m_formatImpl(&formatImpl<T>), m_toIntImpl(&toIntImpl<T>) {}
+
+    void format(std::ostream &out, const char *fmtBegin, const char *fmtEnd,
+                int ntrunc) const {
+        m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
+    }
 
-        int toInt() const
-        {
-            return m_toIntImpl(m_value);
-        }
+    int toInt() const { return m_toIntImpl(m_value); }
 
-    private:
-        template<typename T>
-        TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin,
-                        const char* fmtEnd, int ntrunc, const void* value)
-        {
-            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
-        }
+private:
+    template <typename T>
+    TINYFORMAT_HIDDEN static void
+    formatImpl(std::ostream &out, const char *fmtBegin, const char *fmtEnd,
+               int ntrunc, const void *value) {
+        formatValue(out, fmtBegin, fmtEnd, ntrunc,
+                    *static_cast<const T *>(value));
+    }
 
-        template<typename T>
-        TINYFORMAT_HIDDEN static int toIntImpl(const void* value)
-        {
-            return convertToInt<T>::invoke(*static_cast<const T*>(value));
-        }
+    template <typename T>
+    TINYFORMAT_HIDDEN static int toIntImpl(const void *value) {
+        return convertToInt<T>::invoke(*static_cast<const T *>(value));
+    }
 
-        const void* m_value;
-        void (*m_formatImpl)(std::ostream& out, const char* fmtBegin,
-                             const char* fmtEnd, int ntrunc, const void* value);
-        int (*m_toIntImpl)(const void* value);
+    const void *m_value;
+    void (*m_formatImpl)(std::ostream &out, const char *fmtBegin,
+                         const char *fmtEnd, int ntrunc, const void *value);
+    int (*m_toIntImpl)(const void *value);
 };
 
-
 // Parse and return an integer from the string c, as atoi()
 // On return, c is set to one past the end of the integer.
-inline int parseIntAndAdvance(const char*& c)
-{
+inline int parseIntAndAdvance(const char *&c) {
     int i = 0;
-    for(;*c >= '0' && *c <= '9'; ++c)
-        i = 10*i + (*c - '0');
+    for (; *c >= '0' && *c <= '9'; ++c)
+        i = 10 * i + (*c - '0');
     return i;
 }
 
@@ -545,20 +594,17 @@
 // Skips over any occurrences of '%%', printing a literal '%' to the
 // output.  The position of the first % character of the next
 // nontrivial format spec is returned, or the end of string.
-inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
-{
-    const char* c = fmt;
-    for(;; ++c)
-    {
-        switch(*c)
-        {
+inline const char *printFormatStringLiteral(std::ostream &out,
+                                            const char *fmt) {
+    const char *c = fmt;
+    for (;; ++c) {
+        switch (*c) {
             case '\0':
                 out.write(fmt, c - fmt);
                 return c;
             case '%':
                 out.write(fmt, c - fmt);
-                if(*(c+1) != '%')
-                    return c;
+                if (*(c + 1) != '%') return c;
                 // for "%%", tack trailing % onto next literal section.
                 fmt = ++c;
                 break;
@@ -568,7 +614,6 @@
     }
 }
 
-
 // Parse a format string and set the stream state accordingly.
 //
 // The format mini-language recognized here is meant to be the one from C99,
@@ -579,14 +624,14 @@
 // and ntrunc (for truncating conversions).  argIndex is incremented if
 // necessary to pull out variable width and precision .  The function returns a
 // pointer to the character after the end of the current format spec.
-inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive,
-                                         int& ntrunc, const char* fmtStart,
-                                         const detail::FormatArg* formatters,
-                                         int& argIndex, int numFormatters)
-{
-    if(*fmtStart != '%')
-    {
-        TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
+inline const char *streamStateFromFormat(std::ostream &out,
+                                         bool &spacePadPositive, int &ntrunc,
+                                         const char *fmtStart,
+                                         const detail::FormatArg *formatters,
+                                         int &argIndex, int numFormatters) {
+    if (*fmtStart != '%') {
+        TINYFORMAT_ERROR(
+            "tinyformat: Not enough conversion specifiers in format string");
         return fmtStart;
     }
     // Reset stream state to defaults.
@@ -600,19 +645,16 @@
     bool precisionSet = false;
     bool widthSet = false;
     int widthExtra = 0;
-    const char* c = fmtStart + 1;
+    const char *c = fmtStart + 1;
     // 1) Parse flags
-    for(;; ++c)
-    {
-        switch(*c)
-        {
+    for (;; ++c) {
+        switch (*c) {
             case '#':
                 out.setf(std::ios::showpoint | std::ios::showbase);
                 continue;
             case '0':
                 // overridden by left alignment ('-' flag)
-                if(!(out.flags() & std::ios::left))
-                {
+                if (!(out.flags() & std::ios::left)) {
                     // Use internal padding so that numeric values are
                     // formatted correctly, eg -00010 rather than 000-10
                     out.fill('0');
@@ -625,8 +667,7 @@
                 continue;
             case ' ':
                 // overridden by show positive sign, '+' flag.
-                if(!(out.flags() & std::ios::showpos))
-                    spacePadPositive = true;
+                if (!(out.flags() & std::ios::showpos)) spacePadPositive = true;
                 continue;
             case '+':
                 out.setf(std::ios::showpos);
@@ -639,21 +680,19 @@
         break;
     }
     // 2) Parse width
-    if(*c >= '0' && *c <= '9')
-    {
+    if (*c >= '0' && *c <= '9') {
         widthSet = true;
         out.width(parseIntAndAdvance(c));
     }
-    if(*c == '*')
-    {
+    if (*c == '*') {
         widthSet = true;
         int width = 0;
-        if(argIndex < numFormatters)
+        if (argIndex < numFormatters)
             width = formatters[argIndex++].toInt();
         else
-            TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width");
-        if(width < 0)
-        {
+            TINYFORMAT_ERROR(
+                "tinyformat: Not enough arguments to read variable width");
+        if (width < 0) {
             // negative widths correspond to '-' flag set
             out.fill(' ');
             out.setf(std::ios::left, std::ios::adjustfield);
@@ -663,39 +702,37 @@
         ++c;
     }
     // 3) Parse precision
-    if(*c == '.')
-    {
+    if (*c == '.') {
         ++c;
         int precision = 0;
-        if(*c == '*')
-        {
+        if (*c == '*') {
             ++c;
-            if(argIndex < numFormatters)
+            if (argIndex < numFormatters)
                 precision = formatters[argIndex++].toInt();
             else
-                TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision");
-        }
-        else
-        {
-            if(*c >= '0' && *c <= '9')
+                TINYFORMAT_ERROR("tinyformat: Not enough arguments to read "
+                                 "variable precision");
+        } else {
+            if (*c >= '0' && *c <= '9')
                 precision = parseIntAndAdvance(c);
-            else if(*c == '-') // negative precisions ignored, treated as zero.
+            else if (*c == '-') // negative precisions ignored, treated as zero.
                 parseIntAndAdvance(++c);
         }
         out.precision(precision);
         precisionSet = true;
     }
     // 4) Ignore any C99 length modifier
-    while(*c == 'l' || *c == 'h' || *c == 'L' ||
-          *c == 'j' || *c == 'z' || *c == 't')
+    while (*c == 'l' || *c == 'h' || *c == 'L' || *c == 'j' || *c == 'z' ||
+           *c == 't')
         ++c;
     // 5) We're up to the conversion specifier character.
     // Set stream flags based on conversion specifier (thanks to the
     // boost::format class for forging the way here).
     bool intConversion = false;
-    switch(*c)
-    {
-        case 'u': case 'd': case 'i':
+    switch (*c) {
+        case 'u':
+        case 'd':
+        case 'i':
             out.setf(std::ios::dec, std::ios::basefield);
             intConversion = true;
             break;
@@ -705,7 +742,8 @@
             break;
         case 'X':
             out.setf(std::ios::uppercase);
-        case 'x': case 'p':
+        case 'x':
+        case 'p':
             out.setf(std::ios::hex, std::ios::basefield);
             intConversion = true;
             break;
@@ -727,7 +765,8 @@
             // As in boost::format, let stream decide float format.
             out.flags(out.flags() & ~std::ios::floatfield);
             break;
-        case 'a': case 'A':
+        case 'a':
+        case 'A':
             TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
                              "are not supported");
             break;
@@ -735,8 +774,7 @@
             // Handled as special case inside formatValue()
             break;
         case 's':
-            if(precisionSet)
-                ntrunc = static_cast<int>(out.precision());
+            if (precisionSet) ntrunc = static_cast<int>(out.precision());
             // Make %s print booleans as "true" and "false"
             out.setf(std::ios::boolalpha);
             break;
@@ -751,8 +789,7 @@
         default:
             break;
     }
-    if(intConversion && precisionSet && !widthSet)
-    {
+    if (intConversion && precisionSet && !widthSet) {
         // "precision" for integers gives the minimum number of digits (to be
         // padded with zeros on the left).  This isn't really supported by the
         // iostreams, but we can approximately simulate it with the width if
@@ -761,41 +798,36 @@
         out.setf(std::ios::internal, std::ios::adjustfield);
         out.fill('0');
     }
-    return c+1;
+    return c + 1;
 }
 
-
 //------------------------------------------------------------------------------
-inline void formatImpl(std::ostream& out, const char* fmt,
-                       const detail::FormatArg* formatters,
-                       int numFormatters)
-{
+inline void formatImpl(std::ostream &out, const char *fmt,
+                       const detail::FormatArg *formatters, int numFormatters) {
     // Saved stream state
     std::streamsize origWidth = out.width();
     std::streamsize origPrecision = out.precision();
     std::ios::fmtflags origFlags = out.flags();
     char origFill = out.fill();
 
-    for (int argIndex = 0; argIndex < numFormatters; ++argIndex)
-    {
+    for (int argIndex = 0; argIndex < numFormatters; ++argIndex) {
         // Parse the format string
         fmt = printFormatStringLiteral(out, fmt);
         bool spacePadPositive = false;
         int ntrunc = -1;
-        const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
-                                                   formatters, argIndex, numFormatters);
-        if (argIndex >= numFormatters)
-        {
+        const char *fmtEnd =
+            streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
+                                  formatters, argIndex, numFormatters);
+        if (argIndex >= numFormatters) {
             // Check args remain after reading any variable width/precision
             TINYFORMAT_ERROR("tinyformat: Not enough format arguments");
             return;
         }
-        const FormatArg& arg = formatters[argIndex];
+        const FormatArg &arg = formatters[argIndex];
         // Format the arg into the stream.
-        if(!spacePadPositive)
+        if (!spacePadPositive)
             arg.format(out, fmt, fmtEnd, ntrunc);
-        else
-        {
+        else {
             // The following is a special case with no direct correspondence
             // between stream formatting and the printf() behaviour.  Simulate
             // it crudely by formatting into a temporary string stream and
@@ -805,8 +837,8 @@
             tmpStream.setf(std::ios::showpos);
             arg.format(tmpStream, fmt, fmtEnd, ntrunc);
             std::string result = tmpStream.str(); // allocates... yuck.
-            for(size_t i = 0, iend = result.size(); i < iend; ++i)
-                if(result[i] == '+') result[i] = ' ';
+            for (size_t i = 0, iend = result.size(); i < iend; ++i)
+                if (result[i] == '+') result[i] = ' ';
             out << result;
         }
         fmt = fmtEnd;
@@ -814,8 +846,9 @@
 
     // Print remaining part of format string.
     fmt = printFormatStringLiteral(out, fmt);
-    if(*fmt != '\0')
-        TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
+    if (*fmt != '\0')
+        TINYFORMAT_ERROR(
+            "tinyformat: Too many conversion specifiers in format string");
 
     // Restore stream state
     out.width(origWidth);
@@ -826,77 +859,72 @@
 
 } // namespace detail
 
-
 /// List of template arguments format(), held in a type-opaque way.
 ///
 /// A const reference to FormatList (typedef'd as FormatListRef) may be
 /// conveniently used to pass arguments to non-template functions: All type
 /// information has been stripped from the arguments, leaving just enough of a
 /// common interface to perform formatting as required.
-class FormatList
-{
-    public:
-        FormatList(detail::FormatArg* formatters, int N)
-            : m_formatters(formatters), m_N(N) { }
-
-        friend void vformat(std::ostream& out, const char* fmt,
-                            const FormatList& list);
-
-    private:
-        const detail::FormatArg* m_formatters;
-        int m_N;
+class FormatList {
+public:
+    FormatList(detail::FormatArg *formatters, int N)
+        : m_formatters(formatters), m_N(N) {}
+
+    friend void vformat(std::ostream &out, const char *fmt,
+                        const FormatList &list);
+
+private:
+    const detail::FormatArg *m_formatters;
+    int m_N;
 };
 
 /// Reference to type-opaque format list for passing to vformat()
-typedef const FormatList& FormatListRef;
-
+typedef const FormatList &FormatListRef;
 
 namespace detail {
 
 // Format list subclass with fixed storage to avoid dynamic allocation
-template<int N>
-class FormatListN : public FormatList
-{
-    public:
+template <int N> class FormatListN : public FormatList {
+public:
 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
-        template<typename... Args>
-        FormatListN(const Args&... args)
-            : FormatList(&m_formatterStore[0], N),
-            m_formatterStore { FormatArg(args)... }
-        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
+    template <typename... Args>
+    FormatListN(const Args &... args)
+        : FormatList(&m_formatterStore[0], N),
+          m_formatterStore{FormatArg(args)...} {
+        static_assert(sizeof...(args) == N, "Number of args must be N");
+    }
 #else // C++98 version
-        void init(int) {}
-#       define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n)       \
-                                                               \
-        template<TINYFORMAT_ARGTYPES(n)>                       \
-        FormatListN(TINYFORMAT_VARARGS(n))                     \
-            : FormatList(&m_formatterStore[0], n)              \
-        { assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); }   \
-                                                               \
-        template<TINYFORMAT_ARGTYPES(n)>                       \
-        void init(int i, TINYFORMAT_VARARGS(n))                \
-        {                                                      \
-            m_formatterStore[i] = FormatArg(v1);               \
-            init(i+1 TINYFORMAT_PASSARGS_TAIL(n));             \
-        }
+    void init(int) {}
+#define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n)                              \
+                                                                               \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    FormatListN(TINYFORMAT_VARARGS(n)) : FormatList(&m_formatterStore[0], n) { \
+        assert(n == N);                                                        \
+        init(0, TINYFORMAT_PASSARGS(n));                                       \
+    }                                                                          \
+                                                                               \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    void init(int i, TINYFORMAT_VARARGS(n)) {                                  \
+        m_formatterStore[i] = FormatArg(v1);                                   \
+        init(i + 1 TINYFORMAT_PASSARGS_TAIL(n));                               \
+    }
 
-        TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
-#       undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
+    TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
+#undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
 #endif
 
-    private:
-        FormatArg m_formatterStore[N];
+private:
+    FormatArg m_formatterStore[N];
 };
 
 // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
-template<> class FormatListN<0> : public FormatList
-{
-    public: FormatListN() : FormatList(0, 0) {}
+template <> class FormatListN<0> : public FormatList {
+public:
+    FormatListN() : FormatList(0, 0) {}
 };
 
 } // namespace detail
 
-
 //------------------------------------------------------------------------------
 // Primary API functions
 
@@ -908,24 +936,21 @@
 /// shouldn't be relied upon.  Instead it should be stored as a FormatListRef:
 ///
 ///   FormatListRef formatList = makeFormatList( /*...*/ );
-template<typename... Args>
-detail::FormatListN<sizeof...(Args)> makeFormatList(const Args&... args)
-{
+template <typename... Args>
+detail::FormatListN<sizeof...(Args)> makeFormatList(const Args &... args) {
     return detail::FormatListN<sizeof...(args)>(args...);
 }
 
 #else // C++98 version
 
-inline detail::FormatListN<0> makeFormatList()
-{
+inline detail::FormatListN<0> makeFormatList() {
     return detail::FormatListN<0>();
 }
-#define TINYFORMAT_MAKE_MAKEFORMATLIST(n)                     \
-template<TINYFORMAT_ARGTYPES(n)>                              \
-detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n))  \
-{                                                             \
-    return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n));    \
-}
+#define TINYFORMAT_MAKE_MAKEFORMATLIST(n)                                      \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n)) {             \
+        return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n));                 \
+    }
 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
 #undef TINYFORMAT_MAKE_MAKEFORMATLIST
 
@@ -935,98 +960,83 @@
 ///
 /// The name vformat() is chosen for the semantic similarity to vprintf(): the
 /// list of format arguments is held in a single function argument.
-inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
-{
+inline void vformat(std::ostream &out, const char *fmt, FormatListRef list) {
     detail::formatImpl(out, fmt, list.m_formatters, list.m_N);
 }
 
-
 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 
 /// Format list of arguments to the stream according to given format string.
-template<typename... Args>
-void format(std::ostream& out, const char* fmt, const Args&... args)
-{
+template <typename... Args>
+void format(std::ostream &out, const char *fmt, const Args &... args) {
     vformat(out, fmt, makeFormatList(args...));
 }
 
 /// Format list of arguments according to the given format string and return
 /// the result as a string.
-template<typename... Args>
-std::string format(const char* fmt, const Args&... args)
-{
+template <typename... Args>
+std::string format(const char *fmt, const Args &... args) {
     std::ostringstream oss;
     format(oss, fmt, args...);
     return oss.str();
 }
 
 /// Format list of arguments to std::cout, according to the given format string
-template<typename... Args>
-void printf(const char* fmt, const Args&... args)
-{
+template <typename... Args> void printf(const char *fmt, const Args &... args) {
     format(std::cout, fmt, args...);
 }
 
-template<typename... Args>
-void printfln(const char* fmt, const Args&... args)
-{
+template <typename... Args>
+void printfln(const char *fmt, const Args &... args) {
     format(std::cout, fmt, args...);
     std::cout << '\n';
 }
 
 #else // C++98 version
 
-inline void format(std::ostream& out, const char* fmt)
-{
+inline void format(std::ostream &out, const char *fmt) {
     vformat(out, fmt, makeFormatList());
 }
 
-inline std::string format(const char* fmt)
-{
+inline std::string format(const char *fmt) {
     std::ostringstream oss;
     format(oss, fmt);
     return oss.str();
 }
 
-inline void printf(const char* fmt)
-{
+inline void printf(const char *fmt) {
     format(std::cout, fmt);
 }
 
-inline void printfln(const char* fmt)
-{
+inline void printfln(const char *fmt) {
     format(std::cout, fmt);
     std::cout << '\n';
 }
 
-#define TINYFORMAT_MAKE_FORMAT_FUNCS(n)                                   \
-                                                                          \
-template<TINYFORMAT_ARGTYPES(n)>                                          \
-void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n))    \
-{                                                                         \
-    vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n)));            \
-}                                                                         \
-                                                                          \
-template<TINYFORMAT_ARGTYPES(n)>                                          \
-std::string format(const char* fmt, TINYFORMAT_VARARGS(n))                \
-{                                                                         \
-    std::ostringstream oss;                                               \
-    format(oss, fmt, TINYFORMAT_PASSARGS(n));                             \
-    return oss.str();                                                     \
-}                                                                         \
-                                                                          \
-template<TINYFORMAT_ARGTYPES(n)>                                          \
-void printf(const char* fmt, TINYFORMAT_VARARGS(n))                       \
-{                                                                         \
-    format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                       \
-}                                                                         \
-                                                                          \
-template<TINYFORMAT_ARGTYPES(n)>                                          \
-void printfln(const char* fmt, TINYFORMAT_VARARGS(n))                     \
-{                                                                         \
-    format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                       \
-    std::cout << '\n';                                                    \
-}
+#define TINYFORMAT_MAKE_FORMAT_FUNCS(n)                                        \
+                                                                               \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    void format(std::ostream &out, const char *fmt, TINYFORMAT_VARARGS(n)) {   \
+        vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n)));             \
+    }                                                                          \
+                                                                               \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    std::string format(const char *fmt, TINYFORMAT_VARARGS(n)) {               \
+        std::ostringstream oss;                                                \
+        format(oss, fmt, TINYFORMAT_PASSARGS(n));                              \
+        return oss.str();                                                      \
+    }                                                                          \
+                                                                               \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    void printf(const char *fmt, TINYFORMAT_VARARGS(n)) {                      \
+        format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                        \
+    }                                                                          \
+                                                                               \
+    template <TINYFORMAT_ARGTYPES(n)>                                          \
+    void printfln(const char *fmt, TINYFORMAT_VARARGS(n)) {                    \
+        format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                        \
+        std::cout << '\n';                                                     \
+    }
 
 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
 #undef TINYFORMAT_MAKE_FORMAT_FUNCS
@@ -1034,9 +1044,8 @@
 #endif
 
 // Added for Bitcoin Core
-template<typename... Args>
-std::string format(const std::string &fmt, const Args&... args)
-{
+template <typename... Args>
+std::string format(const std::string &fmt, const Args &... args) {
     std::ostringstream oss;
     format(oss, fmt.c_str(), args...);
     return oss.str();