diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp
index c5e616be1..0137b8f43 100644
--- a/include/boost/multiprecision/detail/default_ops.hpp
+++ b/include/boost/multiprecision/detail/default_ops.hpp
@@ -3045,6 +3045,7 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
    return s;
 }
 
+// clang-format off
 #define UNARY_OP_FUNCTOR(func, category)                                                                                                                                                                  \
    namespace detail {                                                                                                                                                                                     \
    template <class Backend>                                                                                                                                                                               \
@@ -3072,23 +3073,23 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
        inline typename enable_if_c<number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category,                                                                                          \
                                    detail::expression<                                                                                                                                                    \
                                        detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,         \
-                                   detail::expression<tag, A1, A2, A3, A4> >> ::type                                                                                                                      \
+                                   detail::expression<tag, A1, A2, A3, A4> > > ::type                                                                                                                      \
                                                                               func(const detail::expression<tag, A1, A2, A3, A4>& arg)                                                                    \
    {                                                                                                                                                                                                      \
       return detail::expression<                                                                                                                                                                          \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                               \
-             detail::expression<tag, A1, A2, A3, A4>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg); \
+             detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg); \
    }                                                                                                                                                                                                      \
    template <class Backend>                                                                                                                                                                               \
        inline typename enable_if_c<number_category<Backend>::value == category,                                                                                                                           \
                                    detail::expression<                                                                                                                                                    \
                                        detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                               \
-                                   number<Backend, et_on> >> ::type                                                                                                                                       \
+                                   number<Backend, et_on> > > ::type                                                                                                                                       \
                                                              func(const number<Backend, et_on>& arg)                                                                                                      \
    {                                                                                                                                                                                                      \
       return detail::expression<                                                                                                                                                                          \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                     \
-             number<Backend, et_on>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg);                                                                                        \
+             number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg);                                                                                        \
    }                                                                                                                                                                                                      \
    template <class Backend>                                                                                                                                                                               \
    inline typename boost::enable_if_c<                                                                                                                                                                    \
@@ -3162,55 +3163,55 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
        inline typename enable_if_c<number_category<Backend>::value == category,                                                                                                                                                                            \
                                    detail::expression<                                                                                                                                                                                                     \
                                        detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                \
-                                   number<Backend, et_on>, number<Backend, et_on> >> ::type                                                                                                                                                                \
+                                   number<Backend, et_on>, number<Backend, et_on> > > ::type                                                                                                                                                                \
                                                                                      func(const number<Backend, et_on>& arg, const number<Backend, et_on>& a)                                                                                              \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
-             number<Backend, et_on>, number<Backend, et_on>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                                              \
+             number<Backend, et_on>, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                                              \
    }                                                                                                                                                                                                                                                       \
    template <class Backend, class tag, class A1, class A2, class A3, class A4>                                                                                                                                                                             \
        inline typename enable_if_c<                                                                                                                                                                                                                        \
            (number_category<Backend>::value == category) && (boost::is_convertible<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, et_on> >::value),                                                                        \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                        \
-           number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4> >> ::type                                                                                                                                                                       \
+           number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4> > > ::type                                                                                                                                                                       \
                                                                               func(const number<Backend, et_on>& arg, const detail::expression<tag, A1, A2, A3, A4>& a)                                                                                    \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
-             number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                             \
+             number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                             \
    }                                                                                                                                                                                                                                                       \
    template <class tag, class A1, class A2, class A3, class A4, class Backend>                                                                                                                                                                             \
        inline typename enable_if_c<                                                                                                                                                                                                                        \
            (number_category<Backend>::value == category) && (boost::is_convertible<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, et_on> >::value),                                                                        \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                        \
-           detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on> >> ::type                                                                                                                                                                       \
+           detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on> > > ::type                                                                                                                                                                       \
                                                                               func(const detail::expression<tag, A1, A2, A3, A4>& arg, const number<Backend, et_on>& a)                                                                                    \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
-             detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                             \
+             detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                             \
    }                                                                                                                                                                                                                                                       \
    template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>                                                                                                                                    \
        inline typename enable_if_c<                                                                                                                                                                                                                        \
            (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category) && (number_category<detail::expression<tagb, A1b, A2b, A3b, A4b> >::value == category),                                                                          \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                  \
-           detail::expression<tag, A1, A2, A3, A4>, detail::expression<tagb, A1b, A2b, A3b, A4b> >> ::type                                                                                                                                                 \
+           detail::expression<tag, A1, A2, A3, A4>, detail::expression<tagb, A1b, A2b, A3b, A4b> > > ::type                                                                                                                                                 \
                                                                                                     func(const detail::expression<tag, A1, A2, A3, A4>& arg, const detail::expression<tagb, A1b, A2b, A3b, A4b>& a)                                        \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                \
-             detail::expression<tag, A1, A2, A3, A4>, detail::expression<tagb, A1b, A2b, A3b, A4b>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a); \
+             detail::expression<tag, A1, A2, A3, A4>, detail::expression<tagb, A1b, A2b, A3b, A4b> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a); \
    }                                                                                                                                                                                                                                                       \
    template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
        inline typename enable_if_c<                                                                                                                                                                                                                        \
            is_compatible_arithmetic_type<Arithmetic, number<Backend, et_on> >::value && (number_category<Backend>::value == category),                                                                                                                     \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                        \
-           number<Backend, et_on>, Arithmetic>> ::type                                                                                                                                                                                                     \
+           number<Backend, et_on>, Arithmetic> > ::type                                                                                                                                                                                                     \
                                                 func(const number<Backend, et_on>& arg, const Arithmetic& a)                                                                                                                                               \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
@@ -3222,7 +3223,7 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
            is_compatible_arithmetic_type<Arithmetic, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),                                              \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                  \
-           detail::expression<tag, A1, A2, A3, A4>, Arithmetic>> ::type                                                                                                                                                                                    \
+           detail::expression<tag, A1, A2, A3, A4>, Arithmetic> > ::type                                                                                                                                                                                    \
                                                                  func(const detail::expression<tag, A1, A2, A3, A4>& arg, const Arithmetic& a)                                                                                                             \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
@@ -3234,24 +3235,24 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
            is_compatible_arithmetic_type<Arithmetic, number<Backend, et_on> >::value && (number_category<Backend>::value == category),                                                                                                                     \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                        \
-           Arithmetic, number<Backend, et_on> >> ::type                                                                                                                                                                                                    \
+           Arithmetic, number<Backend, et_on> > > ::type                                                                                                                                                                                                    \
                                                  func(const Arithmetic& arg, const number<Backend, et_on>& a)                                                                                                                                              \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
-             Arithmetic, number<Backend, et_on>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                                                          \
+             Arithmetic, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                                                          \
    }                                                                                                                                                                                                                                                       \
    template <class tag, class A1, class A2, class A3, class A4, class Arithmetic>                                                                                                                                                                          \
        inline typename enable_if_c<                                                                                                                                                                                                                        \
            is_compatible_arithmetic_type<Arithmetic, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),                                              \
            detail::expression<                                                                                                                                                                                                                             \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                  \
-           Arithmetic, detail::expression<tag, A1, A2, A3, A4> >> ::type                                                                                                                                                                                   \
+           Arithmetic, detail::expression<tag, A1, A2, A3, A4> > > ::type                                                                                                                                                                                   \
                                                                   func(const Arithmetic& arg, const detail::expression<tag, A1, A2, A3, A4>& a)                                                                                                            \
    {                                                                                                                                                                                                                                                       \
       return detail::expression<                                                                                                                                                                                                                           \
                  detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                \
-             Arithmetic, detail::expression<tag, A1, A2, A3, A4>> (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a);                                   \
+             Arithmetic, detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a);                                   \
    }                                                                                                                                                                                                                                                       \
    template <class Backend>                                                                                                                                                                                                                                \
    inline typename enable_if_c<(number_category<Backend>::value == category),                                                                                                                                                                              \
@@ -3298,7 +3299,7 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
            (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),                                                                                                                          \
            detail::expression<                                                                                                                                                                                      \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                           \
-           detail::expression<tag, A1, A2, A3, A4>, Arg2>> ::type                                                                                                                                                   \
+           detail::expression<tag, A1, A2, A3, A4>, Arg2> > ::type                                                                                                                                                   \
                                                            func(const detail::expression<tag, A1, A2, A3, A4>& arg, Arg2 const& a)                                                                                  \
    {                                                                                                                                                                                                                \
       return detail::expression<                                                                                                                                                                                    \
@@ -3310,7 +3311,7 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
            (number_category<Backend>::value == category),                                                                                                                                                           \
            detail::expression<                                                                                                                                                                                      \
                detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                 \
-           number<Backend, et_on>, Arg2>> ::type                                                                                                                                                                    \
+           number<Backend, et_on>, Arg2> > ::type                                                                                                                                                                    \
                                           func(const number<Backend, et_on>& arg, Arg2 const& a)                                                                                                                    \
    {                                                                                                                                                                                                                \
       return detail::expression<                                                                                                                                                                                    \
@@ -3348,6 +3349,8 @@ sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
                                                                         \
    HETERO_BINARY_OP_FUNCTOR_B(func, Arg2, category)
 
+// clang-format on
+
 namespace detail {
 template <class Backend>
 struct abs_funct