diff --git a/.clang-format b/.clang-format
index 2093ef7..dcb75a6 100644
--- a/.clang-format
+++ b/.clang-format
@@ -5,18 +5,20 @@ AlignConsecutiveDeclarations: true
 AllowShortBlocksOnASingleLine: Always
 AllowShortCompoundRequirementOnASingleLine: true
 AllowShortEnumsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
 AllowShortLoopsOnASingleLine: true
 BasedOnStyle: Chromium
 BinPackArguments: false
 BinPackParameters: false
 ColumnLimit: 100
+ConstructorInitializerIndentWidth: 2
+ContinuationIndentWidth: 2
+Cpp11BracedListStyle: false
 FixNamespaceComments: false
 IndentAccessModifiers: false
 IndentExternBlock: Indent
-IndentPPDirectives: BeforeHash
+IndentWidth: 2
 NamespaceIndentation: All
-SkipMacroDefinitionBody: true
 SpaceBeforeCpp11BracedList: true
 SpacesBeforeTrailingComments: 1
 
diff --git a/.clang-tidy b/.clang-tidy
index 9518fbd..7a11fae 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,3 +1,4 @@
+# noinspection SpellCheckingInspection
 Checks: >
     *,
     -abseil-*,
diff --git a/include/ctre.hpp b/include/ctre.hpp
index 132ee4a..5dfda90 100644
--- a/include/ctre.hpp
+++ b/include/ctre.hpp
@@ -246,27 +246,24 @@ namespace ctll {
     uint8_t  length;
   };
 
-  constexpr length_value_t length_and_value_of_utf8_code_point(
-      uint8_t first_unit
-  ) noexcept {
+  constexpr length_value_t length_and_value_of_utf8_code_point(uint8_t first_unit) noexcept {
     if ((first_unit & 0b1000'0000) == 0b0000'0000)
-      return {static_cast<uint32_t>(first_unit), 1};
+      return { static_cast<uint32_t>(first_unit), 1 };
     else if ((first_unit & 0b1110'0000) == 0b1100'0000)
-      return {static_cast<uint32_t>(first_unit & 0b0001'1111), 2};
+      return { static_cast<uint32_t>(first_unit & 0b0001'1111), 2 };
     else if ((first_unit & 0b1111'0000) == 0b1110'0000)
-      return {static_cast<uint32_t>(first_unit & 0b0000'1111), 3};
+      return { static_cast<uint32_t>(first_unit & 0b0000'1111), 3 };
     else if ((first_unit & 0b1111'1000) == 0b1111'0000)
-      return {static_cast<uint32_t>(first_unit & 0b0000'0111), 4};
+      return { static_cast<uint32_t>(first_unit & 0b0000'0111), 4 };
     else if ((first_unit & 0b1111'1100) == 0b1111'1000)
-      return {static_cast<uint32_t>(first_unit & 0b0000'0011), 5};
+      return { static_cast<uint32_t>(first_unit & 0b0000'0011), 5 };
     else if ((first_unit & 0b1111'1100) == 0b1111'1100)
-      return {static_cast<uint32_t>(first_unit & 0b0000'0001), 6};
+      return { static_cast<uint32_t>(first_unit & 0b0000'0001), 6 };
     else
-      return {0, 0};
+      return { 0, 0 };
   }
 
-  constexpr char32_t
-  value_of_trailing_utf8_code_point(uint8_t unit, bool& correct) noexcept {
+  constexpr char32_t value_of_trailing_utf8_code_point(uint8_t unit, bool& correct) noexcept {
     if ((unit & 0b1100'0000) == 0b1000'0000)
       return unit & 0b0011'1111;
     else {
@@ -275,13 +272,11 @@ namespace ctll {
     }
   }
 
-  constexpr length_value_t length_and_value_of_utf16_code_point(
-      uint16_t first_unit
-  ) noexcept {
+  constexpr length_value_t length_and_value_of_utf16_code_point(uint16_t first_unit) noexcept {
     if ((first_unit & 0b1111110000000000) == 0b1101'1000'0000'0000)
-      return {static_cast<uint32_t>(first_unit & 0b0000001111111111), 2};
+      return { static_cast<uint32_t>(first_unit & 0b0000001111111111), 2 };
     else
-      return {first_unit, 1};
+      return { first_unit, 1 };
   }
 
   struct construct_from_pointer_t {};
@@ -291,47 +286,43 @@ namespace ctll {
   template <size_t N>
   struct fixed_string {
     char32_t content[N] = {};
-    size_t   real_size {0};
-    bool     correct_flag {true};
+    size_t   real_size { 0 };
+    bool     correct_flag { true };
 
     template <typename T>
     constexpr fixed_string(construct_from_pointer_t, const T* input) noexcept {
       if constexpr (std::is_same_v<T, char>) {
 #ifdef CTRE_STRING_IS_UTF8
-        size_t out {0};
-        for (size_t i {0}; i < N; ++i) {
-          if ((i == (N - 1)) && (input[i] == 0)) break;
+        size_t out { 0 };
+        for (size_t i { 0 }; i < N; ++i) {
+          if ((i == (N - 1)) && (input[i] == 0))
+            break;
           length_value_t info = length_and_value_of_utf8_code_point(input[i]);
           switch (info.length) {
             case 6:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 5:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 4:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 3:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 2:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 1:
               content[out++] = static_cast<char32_t>(info.value);
@@ -343,48 +334,45 @@ namespace ctll {
           }
         }
 #else
-        for (size_t i {0}; i < N; ++i) {
+        for (size_t i { 0 }; i < N; ++i) {
           content[i] = static_cast<uint8_t>(input[i]);
-          if ((i == (N - 1)) && (input[i] == 0)) break;
+          if ((i == (N - 1)) && (input[i] == 0))
+            break;
           real_size++;
         }
 #endif
 #if __cpp_char8_t
       } else if constexpr (std::is_same_v<T, char8_t>) {
-        size_t out {0};
-        for (size_t i {0}; i < N; ++i) {
-          if ((i == (N - 1)) && (input[i] == 0)) break;
+        size_t out { 0 };
+        for (size_t i { 0 }; i < N; ++i) {
+          if ((i == (N - 1)) && (input[i] == 0))
+            break;
           length_value_t info = length_and_value_of_utf8_code_point(input[i]);
           switch (info.length) {
             case 6:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 5:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 4:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 3:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 2:
               if (++i < N)
                 info.value =
-                    (info.value << 6) |
-                    value_of_trailing_utf8_code_point(input[i], correct_flag);
+                  (info.value << 6) | value_of_trailing_utf8_code_point(input[i], correct_flag);
               [[fallthrough]];
             case 1:
               content[out++] = static_cast<char32_t>(info.value);
@@ -397,31 +385,31 @@ namespace ctll {
         }
 #endif
       } else if constexpr (std::is_same_v<T, char16_t>) {
-        size_t out {0};
-        for (size_t i {0}; i < N; ++i) {
+        size_t out { 0 };
+        for (size_t i { 0 }; i < N; ++i) {
           length_value_t info = length_and_value_of_utf16_code_point(input[i]);
           if (info.length == 2) {
             if (++i < N) {
               if ((input[i] & 0b1111'1100'0000'0000) == 0b1101'1100'0000'0000) {
                 content[out++] =
-                    ((info.value << 10) | (input[i] & 0b0000'0011'1111'1111)) +
-                    0x10000;
+                  ((info.value << 10) | (input[i] & 0b0000'0011'1111'1111)) + 0x10000;
               } else {
                 correct_flag = false;
                 break;
               }
             }
           } else {
-            if ((i == (N - 1)) && (input[i] == 0)) break;
+            if ((i == (N - 1)) && (input[i] == 0))
+              break;
             content[out++] = info.value;
           }
         }
         real_size = out;
-      } else if constexpr (std::is_same_v<T, wchar_t> ||
-                           std::is_same_v<T, char32_t>) {
-        for (size_t i {0}; i < N; ++i) {
+      } else if constexpr (std::is_same_v<T, wchar_t> || std::is_same_v<T, char32_t>) {
+        for (size_t i { 0 }; i < N; ++i) {
           content[i] = static_cast<char32_t>(input[i]);
-          if ((i == (N - 1)) && (input[i] == 0)) break;
+          if ((i == (N - 1)) && (input[i] == 0))
+            break;
           real_size++;
         }
       }
@@ -429,13 +417,13 @@ namespace ctll {
 
     template <typename T>
     constexpr fixed_string(const std::array<T, N>& in) noexcept
-        : fixed_string {construct_from_pointer, in.data()} {}
+      : fixed_string { construct_from_pointer, in.data() } {}
     template <typename T>
     constexpr fixed_string(const T (&input)[N + 1]) noexcept
-        : fixed_string {construct_from_pointer, input} {}
+      : fixed_string { construct_from_pointer, input } {}
 
     constexpr fixed_string(const fixed_string& other) noexcept {
-      for (size_t i {0}; i < N; ++i) { content[i] = other.content[i]; }
+      for (size_t i { 0 }; i < N; ++i) { content[i] = other.content[i]; }
       real_size    = other.real_size;
       correct_flag = other.correct_flag;
     }
@@ -443,25 +431,25 @@ namespace ctll {
     constexpr size_t          size() const noexcept { return real_size; }
     constexpr const char32_t* begin() const noexcept { return content; }
     constexpr const char32_t* end() const noexcept { return content + size(); }
-    constexpr char32_t        operator[](size_t i) const noexcept {
-      return content[i];
-    }
+    constexpr char32_t        operator[](size_t i) const noexcept { return content[i]; }
     template <size_t M>
     constexpr bool is_same_as(const fixed_string<M>& rhs) const noexcept {
-      if (real_size != rhs.size()) return false;
-      for (size_t i {0}; i != real_size; ++i) {
-        if (content[i] != rhs[i]) return false;
+      if (real_size != rhs.size())
+        return false;
+      for (size_t i { 0 }; i != real_size; ++i) {
+        if (content[i] != rhs[i])
+          return false;
       }
       return true;
     }
     constexpr operator std::basic_string_view<char32_t>() const noexcept {
-      return std::basic_string_view<char32_t> {content, size()};
+      return std::basic_string_view<char32_t> { content, size() };
     }
   };
 
   template <>
   class fixed_string<0> {
-    static constexpr char32_t empty[1] = {0};
+    static constexpr char32_t empty[1] = { 0 };
 
    public:
     template <typename T>
@@ -473,8 +461,8 @@ namespace ctll {
     constexpr const char32_t* begin() const noexcept { return empty; }
     constexpr const char32_t* end() const noexcept { return empty + size(); }
     constexpr char32_t        operator[](size_t) const noexcept { return 0; }
-    constexpr operator std::basic_string_view<char32_t>() const noexcept {
-      return std::basic_string_view<char32_t> {empty, 0};
+    constexpr                 operator std::basic_string_view<char32_t>() const noexcept {
+      return std::basic_string_view<char32_t> { empty, 0 };
     }
   };
 
@@ -583,8 +571,7 @@ namespace ctll {
 
   // concat two lists together left to right
   template <typename... As, typename... Bs>
-  constexpr auto concat(list<As...>, list<Bs...>) noexcept
-      -> list<As..., Bs...> {
+  constexpr auto concat(list<As...>, list<Bs...>) noexcept -> list<As..., Bs...> {
     return {};
   }
 
@@ -611,12 +598,11 @@ namespace ctll {
 
   template <typename Head, typename... As, typename T = _nothing>
   constexpr auto pop_and_get_front(list<Head, As...>, T = T()) noexcept
-      -> list_pop_pair<Head, list<As...>> {
+    -> list_pop_pair<Head, list<As...>> {
     return {};
   }
   template <typename T = _nothing>
-  constexpr auto pop_and_get_front(empty_list, T = T()) noexcept
-      -> list_pop_pair<T, empty_list> {
+  constexpr auto pop_and_get_front(empty_list, T = T()) noexcept -> list_pop_pair<T, empty_list> {
     return {};
   }
 
@@ -634,15 +620,13 @@ namespace ctll {
   template <typename T>
   struct rotate_item {
     template <typename... Ts>
-    friend constexpr auto operator+(list<Ts...>, rotate_item<T>) noexcept
-        -> list<T, Ts...> {
+    friend constexpr auto operator+(list<Ts...>, rotate_item<T>) noexcept -> list<T, Ts...> {
       return {};
     }
   };
 
   template <typename... Ts>
-  constexpr auto rotate(list<Ts...>)
-      -> decltype((list<> {} + ... + rotate_item<Ts> {})) {
+  constexpr auto rotate(list<Ts...>) -> decltype((list<> {} + ... + rotate_item<Ts> {})) {
     return {};
   }
 
@@ -656,8 +640,7 @@ namespace ctll {
     template <typename Y>
     struct wrapper {
       template <typename... Ts>
-      friend constexpr auto operator+(list<Ts...>, wrapper<Y>)
-          -> list<Ts..., Y>;
+      friend constexpr auto operator+(list<Ts...>, wrapper<Y>) -> list<Ts..., Y>;
     };
 
     static constexpr auto check(T) { return std::true_type {}; }
@@ -804,9 +787,7 @@ namespace ctll {
     template <auto V, typename = std::enable_if_t<!contains<V, Def...>::value>>
     constexpr inline neg_set(term<V>) noexcept;
 #else
-    template <
-        auto V,
-        typename = std::enable_if_t<!((Def == V) || ... || false)>>
+    template <auto V, typename = std::enable_if_t<!((Def == V) || ... || false)>>
     constexpr inline neg_set(term<V>) noexcept;
 #endif
   };
@@ -828,9 +809,7 @@ namespace ctll {
     // from the terminal => pop_input
     template <typename Expected, auto V>
     static constexpr auto rule(Expected, term<V>)
-        -> std::enable_if_t<
-            std::is_constructible_v<Expected, term<V>>,
-            ctll::pop_input>;
+      -> std::enable_if_t<std::is_constructible_v<Expected, term<V>>, ctll::pop_input>;
 
     // empty stack and empty input means we are accepting
     static constexpr auto rule(empty_stack_symbol, epsilon) -> ctll::accept;
@@ -865,13 +844,11 @@ namespace ctll {
     using Actions::apply;
     // allow empty_subject to exists
     template <typename Action, auto V>
-    constexpr static auto apply(Action, term<V>, empty_subject)
-        -> empty_subject {
+    constexpr static auto apply(Action, term<V>, empty_subject) -> empty_subject {
       return {};
     }
     template <typename Action>
-    constexpr static auto apply(Action, epsilon, empty_subject)
-        -> empty_subject {
+    constexpr static auto apply(Action, epsilon, empty_subject) -> empty_subject {
       return {};
     }
   };
@@ -906,17 +883,17 @@ namespace ctll {
 
 #if CTLL_CNTTP_COMPILER_CHECK
   template <
-      typename Grammar,
-      ctll::fixed_string input,
-      typename ActionSelector   = empty_actions,
-      bool IgnoreUnknownActions = false>
+    typename Grammar,
+    ctll::fixed_string input,
+    typename ActionSelector   = empty_actions,
+    bool IgnoreUnknownActions = false>
   struct parser { // in c++20
 #else
   template <
-      typename Grammar,
-      const auto& input,
-      typename ActionSelector   = empty_actions,
-      bool IgnoreUnknownActions = false>
+    typename Grammar,
+    const auto& input,
+    typename ActionSelector   = empty_actions,
+    bool IgnoreUnknownActions = false>
   struct parser {
 #endif
 
@@ -930,19 +907,15 @@ namespace ctll {
     static constexpr auto _input = input; // everyone else
 #endif
 
-    using Actions = ctll::conditional<
-        IgnoreUnknownActions,
-        ignore_unknown<ActionSelector>,
-        identity<ActionSelector>>;
+    using Actions = ctll::
+      conditional<IgnoreUnknownActions, ignore_unknown<ActionSelector>, identity<ActionSelector>>;
     using grammar = augment_grammar<Grammar>;
 
     template <size_t Pos, typename Stack, typename Subject, decision Decision>
     struct results {
       static constexpr bool is_correct = Decision == decision::accept;
 
-      constexpr inline CTLL_FORCE_INLINE operator bool() const noexcept {
-        return is_correct;
-      }
+      constexpr inline CTLL_FORCE_INLINE operator bool() const noexcept { return is_correct; }
 
 #ifdef __GNUC__ // workaround to GCC bug
 #if CTLL_CNTTP_COMPILER_CHECK
@@ -961,7 +934,7 @@ namespace ctll {
         if constexpr (Decision == decision::undecided) {
           // parse for current char (RPos) with previous stack and subject :)
           return parser<Grammar, _input, ActionSelector, IgnoreUnknownActions>::
-              template decide<Pos, Stack, Subject>({}, {});
+            template decide<Pos, Stack, Subject>({}, {});
         } else {
           // if there is decision already => just push it to the end of fold
           // expression
@@ -974,9 +947,7 @@ namespace ctll {
     static constexpr auto get_current_term() noexcept {
       if constexpr (Pos < input.size()) {
         constexpr auto value = input[Pos];
-        if constexpr (value <= static_cast<decltype(value)>(
-                                   (std::numeric_limits<char>::max)()
-                               )) {
+        if constexpr (value <= static_cast<decltype(value)>((std::numeric_limits<char>::max)())) {
           return term<static_cast<char>(value)> {};
         } else {
           return term<value> {};
@@ -994,9 +965,7 @@ namespace ctll {
         return epsilon {};
       } else if constexpr ((Pos - 1) < input.size()) {
         constexpr auto value = input[Pos - 1];
-        if constexpr (value <= static_cast<decltype(value)>(
-                                   (std::numeric_limits<char>::max)()
-                               )) {
+        if constexpr (value <= static_cast<decltype(value)>((std::numeric_limits<char>::max)())) {
           return term<static_cast<char>(value)> {};
         } else {
           return term<value> {};
@@ -1007,108 +976,76 @@ namespace ctll {
     }
     // if rule is accept => return true and subject
     template <size_t Pos, typename Terminal, typename Stack, typename Subject>
-    static constexpr auto
-    move(ctll::accept, Terminal, Stack, Subject) noexcept {
-      return typename parser<
-          Grammar, _input, ActionSelector, IgnoreUnknownActions>::
-          template results<Pos, Stack, Subject, decision::accept>();
+    static constexpr auto move(ctll::accept, Terminal, Stack, Subject) noexcept {
+      return typename parser<Grammar, _input, ActionSelector, IgnoreUnknownActions>::
+        template results<Pos, Stack, Subject, decision::accept>();
     }
     // if rule is reject => return false and subject
     template <size_t Pos, typename Terminal, typename Stack, typename Subject>
-    static constexpr auto
-    move(ctll::reject, Terminal, Stack, Subject) noexcept {
-      return typename parser<
-          Grammar, _input, ActionSelector, IgnoreUnknownActions>::
-          template results<Pos, Stack, Subject, decision::reject>();
+    static constexpr auto move(ctll::reject, Terminal, Stack, Subject) noexcept {
+      return typename parser<Grammar, _input, ActionSelector, IgnoreUnknownActions>::
+        template results<Pos, Stack, Subject, decision::reject>();
     }
     // if rule is pop_input => move to next character
     template <size_t Pos, typename Terminal, typename Stack, typename Subject>
-    static constexpr auto
-    move(ctll::pop_input, Terminal, Stack, Subject) noexcept {
-      return typename parser<
-          Grammar, _input, ActionSelector, IgnoreUnknownActions>::
-          template results<Pos + 1, Stack, Subject, decision::undecided>();
+    static constexpr auto move(ctll::pop_input, Terminal, Stack, Subject) noexcept {
+      return typename parser<Grammar, _input, ActionSelector, IgnoreUnknownActions>::
+        template results<Pos + 1, Stack, Subject, decision::undecided>();
     }
     // if rule is string => push it to the front of stack
-    template <
-        size_t Pos,
-        typename... Content,
-        typename Terminal,
-        typename Stack,
-        typename Subject>
-    static constexpr auto move(
-        push<Content...> string,
-        Terminal,
-        Stack   stack,
-        Subject subject
-    ) noexcept {
+    template <size_t Pos, typename... Content, typename Terminal, typename Stack, typename Subject>
+    static constexpr auto
+    move(push<Content...> string, Terminal, Stack stack, Subject subject) noexcept {
       return decide<Pos>(push_front(string, stack), subject);
     }
     // if rule is epsilon (empty string) => continue
     template <size_t Pos, typename Terminal, typename Stack, typename Subject>
-    static constexpr auto
-    move(epsilon, Terminal, Stack stack, Subject subject) noexcept {
+    static constexpr auto move(epsilon, Terminal, Stack stack, Subject subject) noexcept {
       return decide<Pos>(stack, subject);
     }
     // if rule is string with current character at the beginning (term<V>) =>
     // move to next character and push string without the character (quick
     // LL(1))
-    template <
-        size_t Pos,
-        auto   V,
-        typename... Content,
-        typename Stack,
-        typename Subject>
-    static constexpr auto
-    move(push<term<V>, Content...>, term<V>, Stack stack, Subject) noexcept {
+    template <size_t Pos, auto V, typename... Content, typename Stack, typename Subject>
+    static constexpr auto move(push<term<V>, Content...>, term<V>, Stack stack, Subject) noexcept {
       constexpr auto local_input = input;
-      return typename parser<
-          Grammar, local_input, ActionSelector, IgnoreUnknownActions>::
-          template results<
-              Pos + 1, decltype(push_front(list<Content...>(), stack)), Subject,
-              decision::undecided>();
+      return typename parser<Grammar, local_input, ActionSelector, IgnoreUnknownActions>::
+        template results<
+          Pos + 1,
+          decltype(push_front(list<Content...>(), stack)),
+          Subject,
+          decision::undecided>();
     }
     // if rule is string with any character at the beginning (compatible with
     // current term<T>) => move to next character and push string without the
     // character (quick LL(1))
-    template <
-        size_t Pos,
-        auto   V,
-        typename... Content,
-        auto T,
-        typename Stack,
-        typename Subject>
-    static constexpr auto
-    move(push<anything, Content...>, term<T>, Stack stack, Subject) noexcept {
+    template <size_t Pos, auto V, typename... Content, auto T, typename Stack, typename Subject>
+    static constexpr auto move(push<anything, Content...>, term<T>, Stack stack, Subject) noexcept {
       constexpr auto local_input = input;
-      return typename parser<
-          Grammar, local_input, ActionSelector, IgnoreUnknownActions>::
-          template results<
-              Pos + 1, decltype(push_front(list<Content...>(), stack)), Subject,
-              decision::undecided>();
+      return typename parser<Grammar, local_input, ActionSelector, IgnoreUnknownActions>::
+        template results<
+          Pos + 1,
+          decltype(push_front(list<Content...>(), stack)),
+          Subject,
+          decision::undecided>();
     }
     // decide if we need to take action or move
     template <size_t Pos, typename Stack, typename Subject>
-    static constexpr auto
-    decide(Stack previous_stack, Subject previous_subject) noexcept {
+    static constexpr auto decide(Stack previous_stack, Subject previous_subject) noexcept {
       // each call means we pop something from stack
-      auto top_symbol =
-          decltype(ctll::front(previous_stack, empty_stack_symbol()))();
+      auto top_symbol = decltype(ctll::front(previous_stack, empty_stack_symbol()))();
       // gcc pedantic warning
       [[maybe_unused]] auto stack = decltype(ctll::pop_front(previous_stack))();
 
       // in case top_symbol is action type (apply it on previous subject and get
       // new one)
       if constexpr (std::is_base_of_v<ctll::action, decltype(top_symbol)>) {
-        auto subject = Actions::apply(
-            top_symbol, get_previous_term<Pos>(), previous_subject
-        );
+        auto subject = Actions::apply(top_symbol, get_previous_term<Pos>(), previous_subject);
 
         // in case that semantic action is error => reject input
         if constexpr (std::is_same_v<ctll::reject, decltype(subject)>) {
-          return typename parser<
-              Grammar, _input, ActionSelector, IgnoreUnknownActions>::
-              template results<Pos, Stack, Subject, decision::reject>();
+          return typename parser<Grammar, _input, ActionSelector, IgnoreUnknownActions>::
+            template results<Pos, Stack, Subject, decision::reject>();
         } else {
           return decide<Pos>(stack, subject);
         }
@@ -1122,22 +1059,19 @@ namespace ctll {
 
     // trampolines with folded expression
     template <typename Subject, size_t... Pos>
-    static constexpr auto
-    trampoline_decide(Subject, std::index_sequence<Pos...>) noexcept {
+    static constexpr auto trampoline_decide(Subject, std::index_sequence<Pos...>) noexcept {
       // parse everything for first char and than for next and next ...
       // Pos+1 is needed as we want to finish calculation with epsilons on stack
       auto v =
-          (decide<0, typename grammar::start_stack, Subject>({}, {}) + ... +
-           index_placeholder<Pos + 1>());
+        (decide<0, typename grammar::start_stack, Subject>({}, {}) + ... +
+         index_placeholder<Pos + 1>());
       return v;
     }
 
     template <typename Subject = empty_subject>
     static constexpr auto trampoline_decide(Subject subject = {}) noexcept {
       // there will be no recursion, just sequence long as the input
-      return trampoline_decide(
-          subject, std::make_index_sequence<input.size()>()
-      );
+      return trampoline_decide(subject, std::make_index_sequence<input.size()>());
     }
 
     template <typename Subject = empty_subject>
@@ -1294,1250 +1228,982 @@ namespace ctre {
 
     // (q)LL1 function:
     using _others = ctll::neg_set<
-        '!',
-        '$',
-        '\x28',
-        '\x29',
-        '*',
-        '+',
-        ',',
-        '-',
-        '.',
-        '/',
-        ':',
-        '<',
-        '=',
-        '>',
-        '?',
-        'A',
-        'B',
-        'C',
-        'D',
-        'E',
-        'F',
-        'G',
-        'H',
-        'I',
-        'J',
-        'K',
-        'L',
-        'M',
-        'N',
-        'O',
-        'P',
-        'Q',
-        'R',
-        'S',
-        'T',
-        'U',
-        'V',
-        'W',
-        'X',
-        'Y',
-        'Z',
-        '[',
-        '\\',
-        '0',
-        '\"',
-        ']',
-        '^',
-        '_',
-        'a',
-        'b',
-        'c',
-        'd',
-        'e',
-        'f',
-        'g',
-        'h',
-        'i',
-        'j',
-        'k',
-        'l',
-        'm',
-        'n',
-        'o',
-        'p',
-        'q',
-        'r',
-        's',
-        't',
-        'u',
-        'v',
-        'w',
-        'x',
-        'y',
-        'z',
-        '\x7B',
-        '|',
-        '\x7D',
-        '1',
-        '2',
-        '3',
-        '4',
-        '5',
-        '6',
-        '7',
-        '8',
-        '9'>;
+      '!',
+      '$',
+      '\x28',
+      '\x29',
+      '*',
+      '+',
+      ',',
+      '-',
+      '.',
+      '/',
+      ':',
+      '<',
+      '=',
+      '>',
+      '?',
+      'A',
+      'B',
+      'C',
+      'D',
+      'E',
+      'F',
+      'G',
+      'H',
+      'I',
+      'J',
+      'K',
+      'L',
+      'M',
+      'N',
+      'O',
+      'P',
+      'Q',
+      'R',
+      'S',
+      'T',
+      'U',
+      'V',
+      'W',
+      'X',
+      'Y',
+      'Z',
+      '[',
+      '\\',
+      '0',
+      '\"',
+      ']',
+      '^',
+      '_',
+      'a',
+      'b',
+      'c',
+      'd',
+      'e',
+      'f',
+      'g',
+      'h',
+      'i',
+      'j',
+      'k',
+      'l',
+      'm',
+      'n',
+      'o',
+      'p',
+      'q',
+      'r',
+      's',
+      't',
+      'u',
+      'v',
+      'w',
+      'x',
+      'y',
+      'z',
+      '\x7B',
+      '|',
+      '\x7D',
+      '1',
+      '2',
+      '3',
+      '4',
+      '5',
+      '6',
+      '7',
+      '8',
+      '9'>;
     static constexpr auto rule(s, ctll::term<'\\'>)
-        -> ctll::push<ctll::anything, backslash, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, backslash, repeat, string2, content2>;
     static constexpr auto rule(s, ctll::term<'['>)
-        -> ctll::push<ctll::anything, c, repeat, string2, content2>;
-    static constexpr auto rule(s, ctll::term<'\x28'>) -> ctll::push<
-                                                          ctll::anything,
-                                                          prepare_capture,
-                                                          block,
-                                                          repeat,
-                                                          string2,
-                                                          content2>;
+      -> ctll::push<ctll::anything, c, repeat, string2, content2>;
+    static constexpr auto rule(s, ctll::term<'\x28'>)
+      -> ctll::push<ctll::anything, prepare_capture, block, repeat, string2, content2>;
     static constexpr auto rule(s, ctll::term<'^'>)
-        -> ctll::
-            push<ctll::anything, push_assert_begin, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, push_assert_begin, repeat, string2, content2>;
     static constexpr auto rule(s, ctll::term<'$'>)
-        -> ctll::
-            push<ctll::anything, push_assert_end, repeat, string2, content2>;
-    static constexpr auto
-        rule(s, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::
-                push<ctll::anything, push_character, repeat, string2, content2>;
-    static constexpr auto rule(
-        s,
-        _others
-    ) -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
-    static constexpr auto rule(s, ctll::term<'.'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       push_character_anything,
-                                                       repeat,
-                                                       string2,
-                                                       content2>;
+      -> ctll::push<ctll::anything, push_assert_end, repeat, string2, content2>;
+    static constexpr auto rule(s, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
+    static constexpr auto rule(s, _others)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
+    static constexpr auto rule(s, ctll::term<'.'>)
+      -> ctll::push<ctll::anything, push_character_anything, repeat, string2, content2>;
     static constexpr auto rule(s, ctll::term<'|'>)
-        -> ctll::push<ctll::anything, push_empty, content, make_alternate>;
+      -> ctll::push<ctll::anything, push_empty, content, make_alternate>;
     static constexpr auto rule(s, ctll::epsilon) -> ctll::push<push_empty>;
-    static constexpr auto
-        rule(s, ctll::set<'\x29', '*', '+', '?', '\x7B', '\x7D'>)
-            -> ctll::reject;
+    static constexpr auto rule(s, ctll::set<'\x29', '*', '+', '?', '\x7B', '\x7D'>) -> ctll::reject;
 
-    static constexpr auto rule(a, ctll::term<'\\'>) -> ctll::push<
-                                                        ctll::anything,
-                                                        backslash,
-                                                        repeat,
-                                                        string2,
-                                                        content2,
-                                                        make_alternate>;
+    static constexpr auto rule(a, ctll::term<'\\'>)
+      -> ctll::push<ctll::anything, backslash, repeat, string2, content2, make_alternate>;
     static constexpr auto rule(a, ctll::term<'['>)
-        -> ctll::
-            push<ctll::anything, c, repeat, string2, content2, make_alternate>;
-    static constexpr auto rule(a, ctll::term<'\x28'>) -> ctll::push<
+      -> ctll::push<ctll::anything, c, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, ctll::term<'\x28'>)
+      -> ctll::
+        push<ctll::anything, prepare_capture, block, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, ctll::term<'^'>)
+      -> ctll::push<ctll::anything, push_assert_begin, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, ctll::term<'$'>)
+      -> ctll::push<ctll::anything, push_assert_end, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, _others)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, ctll::term<'.'>)
+      -> ctll::
+        push<ctll::anything, push_character_anything, repeat, string2, content2, make_alternate>;
+    static constexpr auto rule(a, ctll::term<'\x29'>) -> ctll::push<push_empty, make_alternate>;
+    static constexpr auto rule(a, ctll::epsilon) -> ctll::push<push_empty, make_alternate>;
+    static constexpr auto rule(a, ctll::set<'*', '+', '?', '\x7B', '|', '\x7D'>) -> ctll::reject;
+
+    static constexpr auto rule(b, ctll::term<','>) -> ctll::push<ctll::anything, n>;
+    static constexpr auto rule(b, ctll::term<'\x7D'>) -> ctll::push<repeat_exactly, ctll::anything>;
+
+    static constexpr auto rule(backslash, ctll::term<'d'>)
+      -> ctll::push<ctll::anything, class_digit>;
+    static constexpr auto rule(backslash, ctll::term<'h'>)
+      -> ctll::push<ctll::anything, class_horizontal_space>;
+    static constexpr auto rule(backslash, ctll::term<'H'>)
+      -> ctll::push<ctll::anything, class_non_horizontal_space>;
+    static constexpr auto rule(backslash, ctll::term<'V'>)
+      -> ctll::push<ctll::anything, class_non_vertical_space>;
+    static constexpr auto rule(backslash, ctll::term<'D'>)
+      -> ctll::push<ctll::anything, class_nondigit>;
+    static constexpr auto rule(backslash, ctll::term<'N'>)
+      -> ctll::push<ctll::anything, class_nonnewline>;
+    static constexpr auto rule(backslash, ctll::term<'S'>)
+      -> ctll::push<ctll::anything, class_nonspace>;
+    static constexpr auto rule(backslash, ctll::term<'W'>)
+      -> ctll::push<ctll::anything, class_nonword>;
+    static constexpr auto rule(backslash, ctll::term<'s'>)
+      -> ctll::push<ctll::anything, class_space>;
+    static constexpr auto rule(backslash, ctll::term<'v'>)
+      -> ctll::push<ctll::anything, class_vertical_space>;
+    static constexpr auto rule(backslash, ctll::term<'w'>)
+      -> ctll::push<ctll::anything, class_word>;
+    static constexpr auto rule(backslash, ctll::set<'1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, create_number, make_back_reference>;
+    static constexpr auto rule(backslash, ctll::term<'g'>)
+      -> ctll::push<ctll::anything, ctll::term<'\x7B'>, m>;
+    static constexpr auto rule(backslash, ctll::term<'p'>)
+      -> ctll::
+        push<ctll::anything, ctll::term<'\x7B'>, property_name, ctll::term<'\x7D'>, make_property>;
+    static constexpr auto rule(backslash, ctll::term<'P'>) -> ctll::push<
+                                                             ctll::anything,
+                                                             ctll::term<'\x7B'>,
+                                                             property_name,
+                                                             ctll::term<'\x7D'>,
+                                                             make_property_negative>;
+    static constexpr auto rule(backslash, ctll::term<'u'>) -> ctll::push<ctll::anything, k>;
+    static constexpr auto rule(backslash, ctll::term<'x'>) -> ctll::push<ctll::anything, l>;
+    static constexpr auto rule(backslash, ctll::term<'A'>)
+      -> ctll::push<ctll::anything, push_assert_subject_begin>;
+    static constexpr auto rule(backslash, ctll::term<'z'>)
+      -> ctll::push<ctll::anything, push_assert_subject_end>;
+    static constexpr auto rule(backslash, ctll::term<'Z'>)
+      -> ctll::push<ctll::anything, push_assert_subject_end_with_lineend>;
+    static constexpr auto
+      rule(backslash, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
+        -> ctll::push<ctll::anything, push_character>;
+    static constexpr auto rule(backslash, ctll::term<'a'>)
+      -> ctll::push<ctll::anything, push_character_alarm>;
+    static constexpr auto rule(backslash, ctll::term<'e'>)
+      -> ctll::push<ctll::anything, push_character_escape>;
+    static constexpr auto rule(backslash, ctll::term<'f'>)
+      -> ctll::push<ctll::anything, push_character_formfeed>;
+    static constexpr auto rule(backslash, ctll::term<'n'>)
+      -> ctll::push<ctll::anything, push_character_newline>;
+    static constexpr auto rule(backslash, ctll::term<'0'>)
+      -> ctll::push<ctll::anything, push_character_null>;
+    static constexpr auto rule(backslash, ctll::term<'r'>)
+      -> ctll::push<ctll::anything, push_character_return_carriage>;
+    static constexpr auto rule(backslash, ctll::term<'t'>)
+      -> ctll::push<ctll::anything, push_character_tab>;
+    static constexpr auto rule(backslash, ctll::term<'B'>)
+      -> ctll::push<ctll::anything, push_not_word_boundary>;
+    static constexpr auto rule(backslash, ctll::term<'b'>)
+      -> ctll::push<ctll::anything, push_word_boundary>;
+
+    static constexpr auto rule(backslash_range, ctll::term<'u'>) -> ctll::push<ctll::anything, k>;
+    static constexpr auto rule(backslash_range, ctll::term<'x'>) -> ctll::push<ctll::anything, l>;
+    static constexpr auto
+      rule(backslash_range, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
+        -> ctll::push<ctll::anything, push_character>;
+    static constexpr auto rule(backslash_range, ctll::term<'a'>)
+      -> ctll::push<ctll::anything, push_character_alarm>;
+    static constexpr auto rule(backslash_range, ctll::term<'e'>)
+      -> ctll::push<ctll::anything, push_character_escape>;
+    static constexpr auto rule(backslash_range, ctll::term<'f'>)
+      -> ctll::push<ctll::anything, push_character_formfeed>;
+    static constexpr auto rule(backslash_range, ctll::term<'n'>)
+      -> ctll::push<ctll::anything, push_character_newline>;
+    static constexpr auto rule(backslash_range, ctll::term<'0'>)
+      -> ctll::push<ctll::anything, push_character_null>;
+    static constexpr auto rule(backslash_range, ctll::term<'r'>)
+      -> ctll::push<ctll::anything, push_character_return_carriage>;
+    static constexpr auto rule(backslash_range, ctll::term<'t'>)
+      -> ctll::push<ctll::anything, push_character_tab>;
+
+    static constexpr auto rule(block, ctll::term<'\\'>) -> ctll::push<
                                                           ctll::anything,
-                                                          prepare_capture,
-                                                          block,
+                                                          backslash,
                                                           repeat,
                                                           string2,
                                                           content2,
-                                                          make_alternate>;
-    static constexpr auto rule(a, ctll::term<'^'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       push_assert_begin,
-                                                       repeat,
-                                                       string2,
-                                                       content2,
-                                                       make_alternate>;
-    static constexpr auto rule(a, ctll::term<'$'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       push_assert_end,
-                                                       repeat,
-                                                       string2,
-                                                       content2,
-                                                       make_alternate>;
-    static constexpr auto
-        rule(a, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                ctll::anything,
-                push_character,
-                repeat,
-                string2,
-                content2,
-                make_alternate>;
-    static constexpr auto rule(a, _others) -> ctll::push<
-                                               ctll::anything,
-                                               push_character,
-                                               repeat,
-                                               string2,
-                                               content2,
-                                               make_alternate>;
-    static constexpr auto rule(a, ctll::term<'.'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       push_character_anything,
-                                                       repeat,
-                                                       string2,
-                                                       content2,
-                                                       make_alternate>;
-    static constexpr auto rule(a, ctll::term<'\x29'>)
-        -> ctll::push<push_empty, make_alternate>;
-    static constexpr auto rule(a, ctll::epsilon)
-        -> ctll::push<push_empty, make_alternate>;
-    static constexpr auto rule(a, ctll::set<'*', '+', '?', '\x7B', '|', '\x7D'>)
-        -> ctll::reject;
-
-    static constexpr auto rule(b, ctll::term<','>)
-        -> ctll::push<ctll::anything, n>;
-    static constexpr auto rule(b, ctll::term<'\x7D'>)
-        -> ctll::push<repeat_exactly, ctll::anything>;
-
-    static constexpr auto rule(backslash, ctll::term<'d'>)
-        -> ctll::push<ctll::anything, class_digit>;
-    static constexpr auto rule(backslash, ctll::term<'h'>)
-        -> ctll::push<ctll::anything, class_horizontal_space>;
-    static constexpr auto rule(backslash, ctll::term<'H'>)
-        -> ctll::push<ctll::anything, class_non_horizontal_space>;
-    static constexpr auto rule(backslash, ctll::term<'V'>)
-        -> ctll::push<ctll::anything, class_non_vertical_space>;
-    static constexpr auto rule(backslash, ctll::term<'D'>)
-        -> ctll::push<ctll::anything, class_nondigit>;
-    static constexpr auto rule(backslash, ctll::term<'N'>)
-        -> ctll::push<ctll::anything, class_nonnewline>;
-    static constexpr auto rule(backslash, ctll::term<'S'>)
-        -> ctll::push<ctll::anything, class_nonspace>;
-    static constexpr auto rule(backslash, ctll::term<'W'>)
-        -> ctll::push<ctll::anything, class_nonword>;
-    static constexpr auto rule(backslash, ctll::term<'s'>)
-        -> ctll::push<ctll::anything, class_space>;
-    static constexpr auto rule(backslash, ctll::term<'v'>)
-        -> ctll::push<ctll::anything, class_vertical_space>;
-    static constexpr auto rule(backslash, ctll::term<'w'>)
-        -> ctll::push<ctll::anything, class_word>;
-    static constexpr auto
-        rule(backslash, ctll::set<'1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, create_number, make_back_reference>;
-    static constexpr auto rule(backslash, ctll::term<'g'>)
-        -> ctll::push<ctll::anything, ctll::term<'\x7B'>, m>;
-    static constexpr auto rule(backslash, ctll::term<'p'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'\x7B'>,
-            property_name,
-            ctll::term<'\x7D'>,
-            make_property>;
-    static constexpr auto rule(backslash, ctll::term<'P'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'\x7B'>,
-            property_name,
-            ctll::term<'\x7D'>,
-            make_property_negative>;
-    static constexpr auto rule(backslash, ctll::term<'u'>)
-        -> ctll::push<ctll::anything, k>;
-    static constexpr auto rule(backslash, ctll::term<'x'>)
-        -> ctll::push<ctll::anything, l>;
-    static constexpr auto rule(backslash, ctll::term<'A'>)
-        -> ctll::push<ctll::anything, push_assert_subject_begin>;
-    static constexpr auto rule(backslash, ctll::term<'z'>)
-        -> ctll::push<ctll::anything, push_assert_subject_end>;
-    static constexpr auto rule(backslash, ctll::term<'Z'>)
-        -> ctll::push<ctll::anything, push_assert_subject_end_with_lineend>;
-    static constexpr auto
-        rule(backslash, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
-            -> ctll::push<ctll::anything, push_character>;
-    static constexpr auto rule(backslash, ctll::term<'a'>)
-        -> ctll::push<ctll::anything, push_character_alarm>;
-    static constexpr auto rule(backslash, ctll::term<'e'>)
-        -> ctll::push<ctll::anything, push_character_escape>;
-    static constexpr auto rule(backslash, ctll::term<'f'>)
-        -> ctll::push<ctll::anything, push_character_formfeed>;
-    static constexpr auto rule(backslash, ctll::term<'n'>)
-        -> ctll::push<ctll::anything, push_character_newline>;
-    static constexpr auto rule(backslash, ctll::term<'0'>)
-        -> ctll::push<ctll::anything, push_character_null>;
-    static constexpr auto rule(backslash, ctll::term<'r'>)
-        -> ctll::push<ctll::anything, push_character_return_carriage>;
-    static constexpr auto rule(backslash, ctll::term<'t'>)
-        -> ctll::push<ctll::anything, push_character_tab>;
-    static constexpr auto rule(backslash, ctll::term<'B'>)
-        -> ctll::push<ctll::anything, push_not_word_boundary>;
-    static constexpr auto rule(backslash, ctll::term<'b'>)
-        -> ctll::push<ctll::anything, push_word_boundary>;
-
-    static constexpr auto rule(backslash_range, ctll::term<'u'>)
-        -> ctll::push<ctll::anything, k>;
-    static constexpr auto rule(backslash_range, ctll::term<'x'>)
-        -> ctll::push<ctll::anything, l>;
-    static constexpr auto
-        rule(backslash_range, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
-            -> ctll::push<ctll::anything, push_character>;
-    static constexpr auto rule(backslash_range, ctll::term<'a'>)
-        -> ctll::push<ctll::anything, push_character_alarm>;
-    static constexpr auto rule(backslash_range, ctll::term<'e'>)
-        -> ctll::push<ctll::anything, push_character_escape>;
-    static constexpr auto rule(backslash_range, ctll::term<'f'>)
-        -> ctll::push<ctll::anything, push_character_formfeed>;
-    static constexpr auto rule(backslash_range, ctll::term<'n'>)
-        -> ctll::push<ctll::anything, push_character_newline>;
-    static constexpr auto rule(backslash_range, ctll::term<'0'>)
-        -> ctll::push<ctll::anything, push_character_null>;
-    static constexpr auto rule(backslash_range, ctll::term<'r'>)
-        -> ctll::push<ctll::anything, push_character_return_carriage>;
-    static constexpr auto rule(backslash_range, ctll::term<'t'>)
-        -> ctll::push<ctll::anything, push_character_tab>;
-
-    static constexpr auto rule(block, ctll::term<'\\'>) -> ctll::push<
+                                                          make_capture,
+                                                          ctll::term<'\x29'>>;
+    static constexpr auto rule(block, ctll::term<'['>)
+      -> ctll::push<ctll::anything, c, repeat, string2, content2, make_capture, ctll::term<'\x29'>>;
+    static constexpr auto rule(block, ctll::term<'?'>) -> ctll::push<ctll::anything, d>;
+    static constexpr auto rule(block, ctll::term<'\x28'>) -> ctll::push<
                                                             ctll::anything,
-                                                            backslash,
+                                                            prepare_capture,
+                                                            block,
                                                             repeat,
                                                             string2,
                                                             content2,
                                                             make_capture,
                                                             ctll::term<'\x29'>>;
-    static constexpr auto rule(block, ctll::term<'['>) -> ctll::push<
-                                                           ctll::anything,
-                                                           c,
-                                                           repeat,
-                                                           string2,
-                                                           content2,
-                                                           make_capture,
-                                                           ctll::term<'\x29'>>;
-    static constexpr auto rule(block, ctll::term<'?'>)
-        -> ctll::push<ctll::anything, d>;
-    static constexpr auto rule(block, ctll::term<'\x28'>)
-        -> ctll::push<
-            ctll::anything,
-            prepare_capture,
-            block,
-            repeat,
-            string2,
-            content2,
-            make_capture,
-            ctll::term<'\x29'>>;
     static constexpr auto rule(block, ctll::term<'^'>) -> ctll::push<
-                                                           ctll::anything,
-                                                           push_assert_begin,
-                                                           repeat,
-                                                           string2,
-                                                           content2,
-                                                           make_capture,
-                                                           ctll::term<'\x29'>>;
+                                                         ctll::anything,
+                                                         push_assert_begin,
+                                                         repeat,
+                                                         string2,
+                                                         content2,
+                                                         make_capture,
+                                                         ctll::term<'\x29'>>;
     static constexpr auto rule(block, ctll::term<'$'>) -> ctll::push<
-                                                           ctll::anything,
-                                                           push_assert_end,
-                                                           repeat,
-                                                           string2,
-                                                           content2,
-                                                           make_capture,
-                                                           ctll::term<'\x29'>>;
-    static constexpr auto
-        rule(block, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                ctll::anything,
-                push_character,
-                repeat,
-                string2,
-                content2,
-                make_capture,
-                ctll::term<'\x29'>>;
+                                                         ctll::anything,
+                                                         push_assert_end,
+                                                         repeat,
+                                                         string2,
+                                                         content2,
+                                                         make_capture,
+                                                         ctll::term<'\x29'>>;
+    static constexpr auto rule(block, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<
+        ctll::anything,
+        push_character,
+        repeat,
+        string2,
+        content2,
+        make_capture,
+        ctll::term<'\x29'>>;
     static constexpr auto rule(block, _others) -> ctll::push<
-                                                   ctll::anything,
-                                                   push_character,
-                                                   repeat,
-                                                   string2,
-                                                   content2,
-                                                   make_capture,
-                                                   ctll::term<'\x29'>>;
-    static constexpr auto rule(block, ctll::term<'.'>)
-        -> ctll::push<
-            ctll::anything,
-            push_character_anything,
-            repeat,
-            string2,
-            content2,
-            make_capture,
-            ctll::term<'\x29'>>;
-    static constexpr auto rule(block, ctll::term<'|'>) -> ctll::push<
-                                                           ctll::anything,
-                                                           push_empty,
-                                                           content,
-                                                           make_alternate,
-                                                           make_capture,
-                                                           ctll::term<'\x29'>>;
+                                                 ctll::anything,
+                                                 push_character,
+                                                 repeat,
+                                                 string2,
+                                                 content2,
+                                                 make_capture,
+                                                 ctll::term<'\x29'>>;
+    static constexpr auto rule(block, ctll::term<'.'>) -> ctll::push<
+                                                         ctll::anything,
+                                                         push_character_anything,
+                                                         repeat,
+                                                         string2,
+                                                         content2,
+                                                         make_capture,
+                                                         ctll::term<'\x29'>>;
+    static constexpr auto rule(block, ctll::term<'|'>)
+      -> ctll::
+        push<ctll::anything, push_empty, content, make_alternate, make_capture, ctll::term<'\x29'>>;
     static constexpr auto rule(block, ctll::term<'\x29'>)
-        -> ctll::push<push_empty, make_capture, ctll::anything>;
-    static constexpr auto rule(block, ctll::set<'*', '+', '\x7B', '\x7D'>)
-        -> ctll::reject;
+      -> ctll::push<push_empty, make_capture, ctll::anything>;
+    static constexpr auto rule(block, ctll::set<'*', '+', '\x7B', '\x7D'>) -> ctll::reject;
 
-    static constexpr auto rule(block_name2, ctll::set<'>', '\x7D'>)
-        -> ctll::epsilon;
-    static constexpr auto rule(block_name2, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>) -> ctll::
-                                                                                                                                                                                                                                                                                                                                                                                      push<ctll::anything, push_name, block_name2>;
+    static constexpr auto rule(block_name2, ctll::set<'>', '\x7D'>) -> ctll::epsilon;
+    static constexpr auto rule(block_name2, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_name, block_name2>;
 
     static constexpr auto rule(c, ctll::term<'['>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<':'>,
-                                                       i,
-                                                       range,
-                                                       set_start,
-                                                       set2b,
-                                                       set_make,
-                                                       ctll::term<']'>>;
-    static constexpr auto rule(c, ctll::term<'\\'>) -> ctll::push<
-                                                        ctll::anything,
-                                                        e,
-                                                        set_start,
-                                                        set2b,
-                                                        set_make,
-                                                        ctll::term<']'>>;
-    static constexpr auto
-        rule(c, ctll::set<'!', '0', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                ctll::anything,
-                push_character,
-                range,
-                set_start,
-                set2b,
-                set_make,
-                ctll::term<']'>>;
-    static constexpr auto rule(c, _others) -> ctll::push<
-                                               ctll::anything,
-                                               push_character,
-                                               range,
-                                               set_start,
-                                               set2b,
-                                               set_make,
-                                               ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<':'>,
+                                                     i,
+                                                     range,
+                                                     set_start,
+                                                     set2b,
+                                                     set_make,
+                                                     ctll::term<']'>>;
+    static constexpr auto rule(c, ctll::term<'\\'>)
+      -> ctll::push<ctll::anything, e, set_start, set2b, set_make, ctll::term<']'>>;
+    static constexpr auto rule(c, ctll::set<'!', '0', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::
+        push<ctll::anything, push_character, range, set_start, set2b, set_make, ctll::term<']'>>;
+    static constexpr auto rule(c, _others)
+      -> ctll::
+        push<ctll::anything, push_character, range, set_start, set2b, set_make, ctll::term<']'>>;
     static constexpr auto rule(c, ctll::term<'^'>)
-        -> ctll::
-            push<ctll::anything, set2a, set_make_negative, ctll::term<']'>>;
+      -> ctll::push<ctll::anything, set2a, set_make_negative, ctll::term<']'>>;
     static constexpr auto rule(c, ctll::set<'-', ']'>) -> ctll::reject;
 
-    static constexpr auto rule(class_named_name, ctll::term<'x'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'d'>,
-            ctll::term<'i'>,
-            ctll::term<'g'>,
-            ctll::term<'i'>,
-            ctll::term<'t'>,
-            class_named_xdigit>;
-    static constexpr auto rule(class_named_name, ctll::term<'d'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'i'>,
-            ctll::term<'g'>,
-            ctll::term<'i'>,
-            ctll::term<'t'>,
-            class_named_digit>;
-    static constexpr auto rule(class_named_name, ctll::term<'b'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'l'>,
-            ctll::term<'a'>,
-            ctll::term<'n'>,
-            ctll::term<'k'>,
-            class_named_blank>;
-    static constexpr auto rule(class_named_name, ctll::term<'c'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'n'>,
-            ctll::term<'t'>,
-            ctll::term<'r'>,
-            ctll::term<'l'>,
-            class_named_cntrl>;
+    static constexpr auto rule(class_named_name, ctll::term<'x'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'d'>,
+                                                                    ctll::term<'i'>,
+                                                                    ctll::term<'g'>,
+                                                                    ctll::term<'i'>,
+                                                                    ctll::term<'t'>,
+                                                                    class_named_xdigit>;
+    static constexpr auto rule(class_named_name, ctll::term<'d'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'i'>,
+                                                                    ctll::term<'g'>,
+                                                                    ctll::term<'i'>,
+                                                                    ctll::term<'t'>,
+                                                                    class_named_digit>;
+    static constexpr auto rule(class_named_name, ctll::term<'b'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'l'>,
+                                                                    ctll::term<'a'>,
+                                                                    ctll::term<'n'>,
+                                                                    ctll::term<'k'>,
+                                                                    class_named_blank>;
+    static constexpr auto rule(class_named_name, ctll::term<'c'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'n'>,
+                                                                    ctll::term<'t'>,
+                                                                    ctll::term<'r'>,
+                                                                    ctll::term<'l'>,
+                                                                    class_named_cntrl>;
     static constexpr auto rule(class_named_name, ctll::term<'w'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'o'>,
-            ctll::term<'r'>,
-            ctll::term<'d'>,
-            class_named_word>;
-    static constexpr auto rule(class_named_name, ctll::term<'l'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'o'>,
-            ctll::term<'w'>,
-            ctll::term<'e'>,
-            ctll::term<'r'>,
-            class_named_lower>;
-    static constexpr auto rule(class_named_name, ctll::term<'s'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'p'>,
-            ctll::term<'a'>,
-            ctll::term<'c'>,
-            ctll::term<'e'>,
-            class_named_space>;
-    static constexpr auto rule(class_named_name, ctll::term<'u'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'p'>,
-            ctll::term<'p'>,
-            ctll::term<'e'>,
-            ctll::term<'r'>,
-            class_named_upper>;
-    static constexpr auto rule(class_named_name, ctll::term<'g'>)
-        -> ctll::push<
-            ctll::anything,
-            ctll::term<'r'>,
-            ctll::term<'a'>,
-            ctll::term<'p'>,
-            ctll::term<'h'>,
-            class_named_graph>;
-    static constexpr auto rule(class_named_name, ctll::term<'a'>)
-        -> ctll::push<ctll::anything, g>;
-    static constexpr auto rule(class_named_name, ctll::term<'p'>)
-        -> ctll::push<ctll::anything, h>;
+      -> ctll::
+        push<ctll::anything, ctll::term<'o'>, ctll::term<'r'>, ctll::term<'d'>, class_named_word>;
+    static constexpr auto rule(class_named_name, ctll::term<'l'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'o'>,
+                                                                    ctll::term<'w'>,
+                                                                    ctll::term<'e'>,
+                                                                    ctll::term<'r'>,
+                                                                    class_named_lower>;
+    static constexpr auto rule(class_named_name, ctll::term<'s'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'p'>,
+                                                                    ctll::term<'a'>,
+                                                                    ctll::term<'c'>,
+                                                                    ctll::term<'e'>,
+                                                                    class_named_space>;
+    static constexpr auto rule(class_named_name, ctll::term<'u'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'p'>,
+                                                                    ctll::term<'p'>,
+                                                                    ctll::term<'e'>,
+                                                                    ctll::term<'r'>,
+                                                                    class_named_upper>;
+    static constexpr auto rule(class_named_name, ctll::term<'g'>) -> ctll::push<
+                                                                    ctll::anything,
+                                                                    ctll::term<'r'>,
+                                                                    ctll::term<'a'>,
+                                                                    ctll::term<'p'>,
+                                                                    ctll::term<'h'>,
+                                                                    class_named_graph>;
+    static constexpr auto rule(class_named_name, ctll::term<'a'>) -> ctll::push<ctll::anything, g>;
+    static constexpr auto rule(class_named_name, ctll::term<'p'>) -> ctll::push<ctll::anything, h>;
 
     static constexpr auto rule(content2, ctll::term<'\x29'>) -> ctll::epsilon;
     static constexpr auto rule(content2, ctll::epsilon) -> ctll::epsilon;
-    static constexpr auto rule(content2, ctll::term<'|'>)
-        -> ctll::push<ctll::anything, a>;
+    static constexpr auto rule(content2, ctll::term<'|'>) -> ctll::push<ctll::anything, a>;
 
     static constexpr auto rule(content, ctll::term<'\\'>)
-        -> ctll::push<ctll::anything, backslash, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, backslash, repeat, string2, content2>;
     static constexpr auto rule(content, ctll::term<'['>)
-        -> ctll::push<ctll::anything, c, repeat, string2, content2>;
-    static constexpr auto rule(content, ctll::term<'\x28'>) -> ctll::push<
-                                                                ctll::anything,
-                                                                prepare_capture,
-                                                                block,
-                                                                repeat,
-                                                                string2,
-                                                                content2>;
+      -> ctll::push<ctll::anything, c, repeat, string2, content2>;
+    static constexpr auto rule(content, ctll::term<'\x28'>)
+      -> ctll::push<ctll::anything, prepare_capture, block, repeat, string2, content2>;
     static constexpr auto rule(content, ctll::term<'^'>)
-        -> ctll::
-            push<ctll::anything, push_assert_begin, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, push_assert_begin, repeat, string2, content2>;
     static constexpr auto rule(content, ctll::term<'$'>)
-        -> ctll::
-            push<ctll::anything, push_assert_end, repeat, string2, content2>;
-    static constexpr auto
-        rule(content, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::
-                push<ctll::anything, push_character, repeat, string2, content2>;
-    static constexpr auto rule(
-        content,
-        _others
-    ) -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, push_assert_end, repeat, string2, content2>;
+    static constexpr auto rule(content, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
+    static constexpr auto rule(content, _others)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
     static constexpr auto rule(content, ctll::term<'.'>)
-        -> ctll::push<
-            ctll::anything,
-            push_character_anything,
-            repeat,
-            string2,
-            content2>;
-    static constexpr auto
-        rule(content, ctll::set<'\x29', '*', '+', '?', '\x7B', '|', '\x7D'>)
-            -> ctll::reject;
+      -> ctll::push<ctll::anything, push_character_anything, repeat, string2, content2>;
+    static constexpr auto rule(content, ctll::set<'\x29', '*', '+', '?', '\x7B', '|', '\x7D'>)
+      -> ctll::reject;
 
     static constexpr auto rule(content_in_capture, ctll::term<'\\'>)
-        -> ctll::push<ctll::anything, backslash, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, backslash, repeat, string2, content2>;
     static constexpr auto rule(content_in_capture, ctll::term<'['>)
-        -> ctll::push<ctll::anything, c, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, c, repeat, string2, content2>;
     static constexpr auto rule(content_in_capture, ctll::term<'\x28'>)
-        -> ctll::push<
-            ctll::anything,
-            prepare_capture,
-            block,
-            repeat,
-            string2,
-            content2>;
+      -> ctll::push<ctll::anything, prepare_capture, block, repeat, string2, content2>;
     static constexpr auto rule(content_in_capture, ctll::term<'^'>)
-        -> ctll::
-            push<ctll::anything, push_assert_begin, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, push_assert_begin, repeat, string2, content2>;
     static constexpr auto rule(content_in_capture, ctll::term<'$'>)
-        -> ctll::
-            push<ctll::anything, push_assert_end, repeat, string2, content2>;
+      -> ctll::push<ctll::anything, push_assert_end, repeat, string2, content2>;
     static constexpr auto
-        rule(content_in_capture, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::
-                push<ctll::anything, push_character, repeat, string2, content2>;
-    static constexpr auto rule(
-        content_in_capture,
-        _others
-    ) -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
+      rule(content_in_capture, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+        -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
+    static constexpr auto rule(content_in_capture, _others)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, content2>;
     static constexpr auto rule(content_in_capture, ctll::term<'.'>)
-        -> ctll::push<
-            ctll::anything,
-            push_character_anything,
-            repeat,
-            string2,
-            content2>;
+      -> ctll::push<ctll::anything, push_character_anything, repeat, string2, content2>;
     static constexpr auto rule(content_in_capture, ctll::term<'|'>)
-        -> ctll::push<ctll::anything, push_empty, content, make_alternate>;
-    static constexpr auto rule(content_in_capture, ctll::term<'\x29'>)
-        -> ctll::push<push_empty>;
-    static constexpr auto
-        rule(content_in_capture, ctll::set<'*', '+', '?', '\x7B', '\x7D'>)
-            -> ctll::reject;
+      -> ctll::push<ctll::anything, push_empty, content, make_alternate>;
+    static constexpr auto rule(content_in_capture, ctll::term<'\x29'>) -> ctll::push<push_empty>;
+    static constexpr auto rule(content_in_capture, ctll::set<'*', '+', '?', '\x7B', '\x7D'>)
+      -> ctll::reject;
 
     static constexpr auto rule(d, ctll::term<'i'>)
-        -> ctll::push<ctll::anything, mode_case_insensitive, mode_switch2>;
+      -> ctll::push<ctll::anything, mode_case_insensitive, mode_switch2>;
     static constexpr auto rule(d, ctll::term<'c'>)
-        -> ctll::push<ctll::anything, mode_case_sensitive, mode_switch2>;
+      -> ctll::push<ctll::anything, mode_case_sensitive, mode_switch2>;
     static constexpr auto rule(d, ctll::term<'m'>)
-        -> ctll::push<ctll::anything, mode_multiline, mode_switch2>;
+      -> ctll::push<ctll::anything, mode_multiline, mode_switch2>;
     static constexpr auto rule(d, ctll::term<'s'>)
-        -> ctll::push<ctll::anything, mode_singleline, mode_switch2>;
-    static constexpr auto rule(d, ctll::term<'<'>)
-        -> ctll::push<ctll::anything, o>;
-    static constexpr auto rule(d, ctll::term<':'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       reset_capture,
-                                                       content_in_capture,
-                                                       ctll::term<'\x29'>>;
+      -> ctll::push<ctll::anything, mode_singleline, mode_switch2>;
+    static constexpr auto rule(d, ctll::term<'<'>) -> ctll::push<ctll::anything, o>;
+    static constexpr auto rule(d, ctll::term<':'>)
+      -> ctll::push<ctll::anything, reset_capture, content_in_capture, ctll::term<'\x29'>>;
     static constexpr auto rule(d, ctll::term<'>'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       reset_capture,
-                                                       start_atomic,
-                                                       content_in_capture,
-                                                       make_atomic,
-                                                       ctll::term<'\x29'>>;
+                                                     ctll::anything,
+                                                     reset_capture,
+                                                     start_atomic,
+                                                     content_in_capture,
+                                                     make_atomic,
+                                                     ctll::term<'\x29'>>;
     static constexpr auto rule(d, ctll::term<'!'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       reset_capture,
-                                                       start_lookahead_negative,
-                                                       content_in_capture,
-                                                       look_finish,
-                                                       ctll::term<'\x29'>>;
+                                                     ctll::anything,
+                                                     reset_capture,
+                                                     start_lookahead_negative,
+                                                     content_in_capture,
+                                                     look_finish,
+                                                     ctll::term<'\x29'>>;
     static constexpr auto rule(d, ctll::term<'='>) -> ctll::push<
-                                                       ctll::anything,
-                                                       reset_capture,
-                                                       start_lookahead_positive,
-                                                       content_in_capture,
-                                                       look_finish,
-                                                       ctll::term<'\x29'>>;
+                                                     ctll::anything,
+                                                     reset_capture,
+                                                     start_lookahead_positive,
+                                                     content_in_capture,
+                                                     look_finish,
+                                                     ctll::term<'\x29'>>;
 
-    static constexpr auto rule(e, ctll::term<'d'>)
-        -> ctll::push<ctll::anything, class_digit>;
+    static constexpr auto rule(e, ctll::term<'d'>) -> ctll::push<ctll::anything, class_digit>;
     static constexpr auto rule(e, ctll::term<'h'>)
-        -> ctll::push<ctll::anything, class_horizontal_space>;
+      -> ctll::push<ctll::anything, class_horizontal_space>;
     static constexpr auto rule(e, ctll::term<'H'>)
-        -> ctll::push<ctll::anything, class_non_horizontal_space>;
+      -> ctll::push<ctll::anything, class_non_horizontal_space>;
     static constexpr auto rule(e, ctll::term<'V'>)
-        -> ctll::push<ctll::anything, class_non_vertical_space>;
-    static constexpr auto rule(e, ctll::term<'D'>)
-        -> ctll::push<ctll::anything, class_nondigit>;
-    static constexpr auto rule(e, ctll::term<'N'>)
-        -> ctll::push<ctll::anything, class_nonnewline>;
-    static constexpr auto rule(e, ctll::term<'S'>)
-        -> ctll::push<ctll::anything, class_nonspace>;
-    static constexpr auto rule(e, ctll::term<'W'>)
-        -> ctll::push<ctll::anything, class_nonword>;
-    static constexpr auto rule(e, ctll::term<'s'>)
-        -> ctll::push<ctll::anything, class_space>;
+      -> ctll::push<ctll::anything, class_non_vertical_space>;
+    static constexpr auto rule(e, ctll::term<'D'>) -> ctll::push<ctll::anything, class_nondigit>;
+    static constexpr auto rule(e, ctll::term<'N'>) -> ctll::push<ctll::anything, class_nonnewline>;
+    static constexpr auto rule(e, ctll::term<'S'>) -> ctll::push<ctll::anything, class_nonspace>;
+    static constexpr auto rule(e, ctll::term<'W'>) -> ctll::push<ctll::anything, class_nonword>;
+    static constexpr auto rule(e, ctll::term<'s'>) -> ctll::push<ctll::anything, class_space>;
     static constexpr auto rule(e, ctll::term<'v'>)
-        -> ctll::push<ctll::anything, class_vertical_space>;
-    static constexpr auto rule(e, ctll::term<'w'>)
-        -> ctll::push<ctll::anything, class_word>;
-    static constexpr auto rule(e, ctll::term<'p'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'\x7B'>,
-                                                       property_name,
-                                                       ctll::term<'\x7D'>,
-                                                       make_property>;
+      -> ctll::push<ctll::anything, class_vertical_space>;
+    static constexpr auto rule(e, ctll::term<'w'>) -> ctll::push<ctll::anything, class_word>;
+    static constexpr auto rule(e, ctll::term<'p'>)
+      -> ctll::
+        push<ctll::anything, ctll::term<'\x7B'>, property_name, ctll::term<'\x7D'>, make_property>;
     static constexpr auto rule(e, ctll::term<'P'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'\x7B'>,
-                                                       property_name,
-                                                       ctll::term<'\x7D'>,
-                                                       make_property_negative>;
-    static constexpr auto rule(e, ctll::term<'u'>)
-        -> ctll::push<ctll::anything, k, range>;
-    static constexpr auto rule(e, ctll::term<'x'>)
-        -> ctll::push<ctll::anything, l, range>;
+                                                     ctll::anything,
+                                                     ctll::term<'\x7B'>,
+                                                     property_name,
+                                                     ctll::term<'\x7D'>,
+                                                     make_property_negative>;
+    static constexpr auto rule(e, ctll::term<'u'>) -> ctll::push<ctll::anything, k, range>;
+    static constexpr auto rule(e, ctll::term<'x'>) -> ctll::push<ctll::anything, l, range>;
     static constexpr auto
-        rule(e, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
-            -> ctll::push<ctll::anything, push_character, range>;
+      rule(e, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
+        -> ctll::push<ctll::anything, push_character, range>;
     static constexpr auto rule(e, ctll::term<'a'>)
-        -> ctll::push<ctll::anything, push_character_alarm, range>;
+      -> ctll::push<ctll::anything, push_character_alarm, range>;
     static constexpr auto rule(e, ctll::term<'e'>)
-        -> ctll::push<ctll::anything, push_character_escape, range>;
+      -> ctll::push<ctll::anything, push_character_escape, range>;
     static constexpr auto rule(e, ctll::term<'f'>)
-        -> ctll::push<ctll::anything, push_character_formfeed, range>;
+      -> ctll::push<ctll::anything, push_character_formfeed, range>;
     static constexpr auto rule(e, ctll::term<'n'>)
-        -> ctll::push<ctll::anything, push_character_newline, range>;
+      -> ctll::push<ctll::anything, push_character_newline, range>;
     static constexpr auto rule(e, ctll::term<'0'>)
-        -> ctll::push<ctll::anything, push_character_null, range>;
+      -> ctll::push<ctll::anything, push_character_null, range>;
     static constexpr auto rule(e, ctll::term<'r'>)
-        -> ctll::push<ctll::anything, push_character_return_carriage, range>;
+      -> ctll::push<ctll::anything, push_character_return_carriage, range>;
     static constexpr auto rule(e, ctll::term<'t'>)
-        -> ctll::push<ctll::anything, push_character_tab, range>;
+      -> ctll::push<ctll::anything, push_character_tab, range>;
 
-    static constexpr auto rule(f, ctll::term<'d'>)
-        -> ctll::push<ctll::anything, class_digit>;
+    static constexpr auto rule(f, ctll::term<'d'>) -> ctll::push<ctll::anything, class_digit>;
     static constexpr auto rule(f, ctll::term<'h'>)
-        -> ctll::push<ctll::anything, class_horizontal_space>;
+      -> ctll::push<ctll::anything, class_horizontal_space>;
     static constexpr auto rule(f, ctll::term<'H'>)
-        -> ctll::push<ctll::anything, class_non_horizontal_space>;
+      -> ctll::push<ctll::anything, class_non_horizontal_space>;
     static constexpr auto rule(f, ctll::term<'V'>)
-        -> ctll::push<ctll::anything, class_non_vertical_space>;
-    static constexpr auto rule(f, ctll::term<'D'>)
-        -> ctll::push<ctll::anything, class_nondigit>;
-    static constexpr auto rule(f, ctll::term<'N'>)
-        -> ctll::push<ctll::anything, class_nonnewline>;
-    static constexpr auto rule(f, ctll::term<'S'>)
-        -> ctll::push<ctll::anything, class_nonspace>;
-    static constexpr auto rule(f, ctll::term<'W'>)
-        -> ctll::push<ctll::anything, class_nonword>;
-    static constexpr auto rule(f, ctll::term<'s'>)
-        -> ctll::push<ctll::anything, class_space>;
+      -> ctll::push<ctll::anything, class_non_vertical_space>;
+    static constexpr auto rule(f, ctll::term<'D'>) -> ctll::push<ctll::anything, class_nondigit>;
+    static constexpr auto rule(f, ctll::term<'N'>) -> ctll::push<ctll::anything, class_nonnewline>;
+    static constexpr auto rule(f, ctll::term<'S'>) -> ctll::push<ctll::anything, class_nonspace>;
+    static constexpr auto rule(f, ctll::term<'W'>) -> ctll::push<ctll::anything, class_nonword>;
+    static constexpr auto rule(f, ctll::term<'s'>) -> ctll::push<ctll::anything, class_space>;
     static constexpr auto rule(f, ctll::term<'v'>)
-        -> ctll::push<ctll::anything, class_vertical_space>;
-    static constexpr auto rule(f, ctll::term<'w'>)
-        -> ctll::push<ctll::anything, class_word>;
-    static constexpr auto rule(f, ctll::term<'p'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'\x7B'>,
-                                                       property_name,
-                                                       ctll::term<'\x7D'>,
-                                                       make_property>;
+      -> ctll::push<ctll::anything, class_vertical_space>;
+    static constexpr auto rule(f, ctll::term<'w'>) -> ctll::push<ctll::anything, class_word>;
+    static constexpr auto rule(f, ctll::term<'p'>)
+      -> ctll::
+        push<ctll::anything, ctll::term<'\x7B'>, property_name, ctll::term<'\x7D'>, make_property>;
     static constexpr auto rule(f, ctll::term<'P'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'\x7B'>,
-                                                       property_name,
-                                                       ctll::term<'\x7D'>,
-                                                       make_property_negative>;
-    static constexpr auto rule(f, ctll::term<'u'>)
-        -> ctll::push<ctll::anything, k, range>;
-    static constexpr auto rule(f, ctll::term<'x'>)
-        -> ctll::push<ctll::anything, l, range>;
+                                                     ctll::anything,
+                                                     ctll::term<'\x7B'>,
+                                                     property_name,
+                                                     ctll::term<'\x7D'>,
+                                                     make_property_negative>;
+    static constexpr auto rule(f, ctll::term<'u'>) -> ctll::push<ctll::anything, k, range>;
+    static constexpr auto rule(f, ctll::term<'x'>) -> ctll::push<ctll::anything, l, range>;
     static constexpr auto
-        rule(f, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
-            -> ctll::push<ctll::anything, push_character, range>;
+      rule(f, ctll::set<'$', '\x28', '\x29', '*', '+', '-', '.', '/', '<', '>', '?', '[', '\\', '\"', ']', '^', '\x7B', '|', '\x7D'>)
+        -> ctll::push<ctll::anything, push_character, range>;
     static constexpr auto rule(f, ctll::term<'a'>)
-        -> ctll::push<ctll::anything, push_character_alarm, range>;
+      -> ctll::push<ctll::anything, push_character_alarm, range>;
     static constexpr auto rule(f, ctll::term<'e'>)
-        -> ctll::push<ctll::anything, push_character_escape, range>;
+      -> ctll::push<ctll::anything, push_character_escape, range>;
     static constexpr auto rule(f, ctll::term<'f'>)
-        -> ctll::push<ctll::anything, push_character_formfeed, range>;
+      -> ctll::push<ctll::anything, push_character_formfeed, range>;
     static constexpr auto rule(f, ctll::term<'n'>)
-        -> ctll::push<ctll::anything, push_character_newline, range>;
+      -> ctll::push<ctll::anything, push_character_newline, range>;
     static constexpr auto rule(f, ctll::term<'0'>)
-        -> ctll::push<ctll::anything, push_character_null, range>;
+      -> ctll::push<ctll::anything, push_character_null, range>;
     static constexpr auto rule(f, ctll::term<'r'>)
-        -> ctll::push<ctll::anything, push_character_return_carriage, range>;
+      -> ctll::push<ctll::anything, push_character_return_carriage, range>;
     static constexpr auto rule(f, ctll::term<'t'>)
-        -> ctll::push<ctll::anything, push_character_tab, range>;
+      -> ctll::push<ctll::anything, push_character_tab, range>;
 
-    static constexpr auto rule(g, ctll::term<'s'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'c'>,
-                                                       ctll::term<'i'>,
-                                                       ctll::term<'i'>,
-                                                       class_named_ascii>;
-    static constexpr auto rule(g, ctll::term<'l'>)
-        -> ctll::push<ctll::anything, p>;
+    static constexpr auto rule(g, ctll::term<'s'>)
+      -> ctll::
+        push<ctll::anything, ctll::term<'c'>, ctll::term<'i'>, ctll::term<'i'>, class_named_ascii>;
+    static constexpr auto rule(g, ctll::term<'l'>) -> ctll::push<ctll::anything, p>;
 
-    static constexpr auto rule(h, ctll::term<'r'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'i'>,
-                                                       ctll::term<'n'>,
-                                                       ctll::term<'t'>,
-                                                       class_named_print>;
-    static constexpr auto rule(h, ctll::term<'u'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'n'>,
-                                                       ctll::term<'c'>,
-                                                       ctll::term<'t'>,
-                                                       class_named_punct>;
+    static constexpr auto rule(h, ctll::term<'r'>)
+      -> ctll::
+        push<ctll::anything, ctll::term<'i'>, ctll::term<'n'>, ctll::term<'t'>, class_named_print>;
+    static constexpr auto rule(h, ctll::term<'u'>)
+      -> ctll::
+        push<ctll::anything, ctll::term<'n'>, ctll::term<'c'>, ctll::term<'t'>, class_named_punct>;
 
-    static constexpr auto rule(hexdec_repeat, ctll::term<'\x7D'>)
-        -> ctll::epsilon;
+    static constexpr auto rule(hexdec_repeat, ctll::term<'\x7D'>) -> ctll::epsilon;
     static constexpr auto
-        rule(hexdec_repeat, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, push_hexdec, hexdec_repeat>;
+      rule(hexdec_repeat, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+        -> ctll::push<ctll::anything, push_hexdec, hexdec_repeat>;
 
     static constexpr auto rule(i, ctll::term<'^'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       class_named_name,
-                                                       negate_class_named,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     class_named_name,
+                                                     negate_class_named,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'x'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'d'>,
-                                                       ctll::term<'i'>,
-                                                       ctll::term<'g'>,
-                                                       ctll::term<'i'>,
-                                                       ctll::term<'t'>,
-                                                       class_named_xdigit,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'d'>,
+                                                     ctll::term<'i'>,
+                                                     ctll::term<'g'>,
+                                                     ctll::term<'i'>,
+                                                     ctll::term<'t'>,
+                                                     class_named_xdigit,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'d'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'i'>,
-                                                       ctll::term<'g'>,
-                                                       ctll::term<'i'>,
-                                                       ctll::term<'t'>,
-                                                       class_named_digit,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'i'>,
+                                                     ctll::term<'g'>,
+                                                     ctll::term<'i'>,
+                                                     ctll::term<'t'>,
+                                                     class_named_digit,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'b'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'l'>,
-                                                       ctll::term<'a'>,
-                                                       ctll::term<'n'>,
-                                                       ctll::term<'k'>,
-                                                       class_named_blank,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'l'>,
+                                                     ctll::term<'a'>,
+                                                     ctll::term<'n'>,
+                                                     ctll::term<'k'>,
+                                                     class_named_blank,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'c'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'n'>,
-                                                       ctll::term<'t'>,
-                                                       ctll::term<'r'>,
-                                                       ctll::term<'l'>,
-                                                       class_named_cntrl,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'n'>,
+                                                     ctll::term<'t'>,
+                                                     ctll::term<'r'>,
+                                                     ctll::term<'l'>,
+                                                     class_named_cntrl,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'w'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'o'>,
-                                                       ctll::term<'r'>,
-                                                       ctll::term<'d'>,
-                                                       class_named_word,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'o'>,
+                                                     ctll::term<'r'>,
+                                                     ctll::term<'d'>,
+                                                     class_named_word,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'l'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'o'>,
-                                                       ctll::term<'w'>,
-                                                       ctll::term<'e'>,
-                                                       ctll::term<'r'>,
-                                                       class_named_lower,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'o'>,
+                                                     ctll::term<'w'>,
+                                                     ctll::term<'e'>,
+                                                     ctll::term<'r'>,
+                                                     class_named_lower,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'s'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'p'>,
-                                                       ctll::term<'a'>,
-                                                       ctll::term<'c'>,
-                                                       ctll::term<'e'>,
-                                                       class_named_space,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'p'>,
+                                                     ctll::term<'a'>,
+                                                     ctll::term<'c'>,
+                                                     ctll::term<'e'>,
+                                                     class_named_space,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'u'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'p'>,
-                                                       ctll::term<'p'>,
-                                                       ctll::term<'e'>,
-                                                       ctll::term<'r'>,
-                                                       class_named_upper,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'p'>,
+                                                     ctll::term<'p'>,
+                                                     ctll::term<'e'>,
+                                                     ctll::term<'r'>,
+                                                     class_named_upper,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'g'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'r'>,
-                                                       ctll::term<'a'>,
-                                                       ctll::term<'p'>,
-                                                       ctll::term<'h'>,
-                                                       class_named_graph,
-                                                       ctll::term<':'>,
-                                                       ctll::term<']'>>;
+                                                     ctll::anything,
+                                                     ctll::term<'r'>,
+                                                     ctll::term<'a'>,
+                                                     ctll::term<'p'>,
+                                                     ctll::term<'h'>,
+                                                     class_named_graph,
+                                                     ctll::term<':'>,
+                                                     ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'a'>)
-        -> ctll::push<ctll::anything, g, ctll::term<':'>, ctll::term<']'>>;
+      -> ctll::push<ctll::anything, g, ctll::term<':'>, ctll::term<']'>>;
     static constexpr auto rule(i, ctll::term<'p'>)
-        -> ctll::push<ctll::anything, h, ctll::term<':'>, ctll::term<']'>>;
+      -> ctll::push<ctll::anything, h, ctll::term<':'>, ctll::term<']'>>;
 
     static constexpr auto rule(j, ctll::term<'\\'>)
-        -> ctll::push<ctll::anything, backslash_range, make_range>;
-    static constexpr auto
-        rule(j, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '^', '0', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, push_character, make_range>;
+      -> ctll::push<ctll::anything, backslash_range, make_range>;
+    static constexpr auto rule(j, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '^', '0', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_character, make_range>;
     static constexpr auto rule(j, _others)
-        -> ctll::push<ctll::anything, push_character, make_range>;
+      -> ctll::push<ctll::anything, push_character, make_range>;
     static constexpr auto rule(j, ctll::set<'-', '[', ']'>) -> ctll::reject;
 
     static constexpr auto rule(k, ctll::term<'\x7B'>) -> ctll::push<
-                                                          create_hexdec,
-                                                          ctll::anything,
-                                                          ctll::set<
-                                                              '0',
-                                                              '1',
-                                                              '2',
-                                                              '3',
-                                                              '4',
-                                                              '5',
-                                                              '6',
-                                                              '7',
-                                                              '8',
-                                                              '9',
-                                                              'A',
-                                                              'B',
-                                                              'C',
-                                                              'D',
-                                                              'E',
-                                                              'F',
-                                                              'a',
-                                                              'b',
-                                                              'c',
-                                                              'd',
-                                                              'e',
-                                                              'f'>,
-                                                          push_hexdec,
-                                                          hexdec_repeat,
-                                                          ctll::term<'\x7D'>,
-                                                          finish_hexdec>;
+                                                        create_hexdec,
+                                                        ctll::anything,
+                                                        ctll::set<
+                                                          '0',
+                                                          '1',
+                                                          '2',
+                                                          '3',
+                                                          '4',
+                                                          '5',
+                                                          '6',
+                                                          '7',
+                                                          '8',
+                                                          '9',
+                                                          'A',
+                                                          'B',
+                                                          'C',
+                                                          'D',
+                                                          'E',
+                                                          'F',
+                                                          'a',
+                                                          'b',
+                                                          'c',
+                                                          'd',
+                                                          'e',
+                                                          'f'>,
+                                                        push_hexdec,
+                                                        hexdec_repeat,
+                                                        ctll::term<'\x7D'>,
+                                                        finish_hexdec>;
     static constexpr auto
-        rule(k, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                create_hexdec,
-                ctll::anything,
-                push_hexdec,
-                ctll::set<
-                    '0',
-                    '1',
-                    '2',
-                    '3',
-                    '4',
-                    '5',
-                    '6',
-                    '7',
-                    '8',
-                    '9',
-                    'A',
-                    'B',
-                    'C',
-                    'D',
-                    'E',
-                    'F',
-                    'a',
-                    'b',
-                    'c',
-                    'd',
-                    'e',
-                    'f'>,
-                push_hexdec,
-                ctll::set<
-                    '0',
-                    '1',
-                    '2',
-                    '3',
-                    '4',
-                    '5',
-                    '6',
-                    '7',
-                    '8',
-                    '9',
-                    'A',
-                    'B',
-                    'C',
-                    'D',
-                    'E',
-                    'F',
-                    'a',
-                    'b',
-                    'c',
-                    'd',
-                    'e',
-                    'f'>,
-                push_hexdec,
-                ctll::set<
-                    '0',
-                    '1',
-                    '2',
-                    '3',
-                    '4',
-                    '5',
-                    '6',
-                    '7',
-                    '8',
-                    '9',
-                    'A',
-                    'B',
-                    'C',
-                    'D',
-                    'E',
-                    'F',
-                    'a',
-                    'b',
-                    'c',
-                    'd',
-                    'e',
-                    'f'>,
-                push_hexdec,
-                finish_hexdec>;
+      rule(k, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+        -> ctll::push<
+          create_hexdec,
+          ctll::anything,
+          push_hexdec,
+          ctll::set<
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'A',
+            'B',
+            'C',
+            'D',
+            'E',
+            'F',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f'>,
+          push_hexdec,
+          ctll::set<
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'A',
+            'B',
+            'C',
+            'D',
+            'E',
+            'F',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f'>,
+          push_hexdec,
+          ctll::set<
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'A',
+            'B',
+            'C',
+            'D',
+            'E',
+            'F',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f'>,
+          push_hexdec,
+          finish_hexdec>;
 
     static constexpr auto rule(l, ctll::term<'\x7B'>) -> ctll::push<
-                                                          create_hexdec,
-                                                          ctll::anything,
-                                                          ctll::set<
-                                                              '0',
-                                                              '1',
-                                                              '2',
-                                                              '3',
-                                                              '4',
-                                                              '5',
-                                                              '6',
-                                                              '7',
-                                                              '8',
-                                                              '9',
-                                                              'A',
-                                                              'B',
-                                                              'C',
-                                                              'D',
-                                                              'E',
-                                                              'F',
-                                                              'a',
-                                                              'b',
-                                                              'c',
-                                                              'd',
-                                                              'e',
-                                                              'f'>,
-                                                          push_hexdec,
-                                                          hexdec_repeat,
-                                                          ctll::term<'\x7D'>,
-                                                          finish_hexdec>;
+                                                        create_hexdec,
+                                                        ctll::anything,
+                                                        ctll::set<
+                                                          '0',
+                                                          '1',
+                                                          '2',
+                                                          '3',
+                                                          '4',
+                                                          '5',
+                                                          '6',
+                                                          '7',
+                                                          '8',
+                                                          '9',
+                                                          'A',
+                                                          'B',
+                                                          'C',
+                                                          'D',
+                                                          'E',
+                                                          'F',
+                                                          'a',
+                                                          'b',
+                                                          'c',
+                                                          'd',
+                                                          'e',
+                                                          'f'>,
+                                                        push_hexdec,
+                                                        hexdec_repeat,
+                                                        ctll::term<'\x7D'>,
+                                                        finish_hexdec>;
     static constexpr auto
-        rule(l, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                create_hexdec,
-                ctll::anything,
-                push_hexdec,
-                ctll::set<
-                    '0',
-                    '1',
-                    '2',
-                    '3',
-                    '4',
-                    '5',
-                    '6',
-                    '7',
-                    '8',
-                    '9',
-                    'A',
-                    'B',
-                    'C',
-                    'D',
-                    'E',
-                    'F',
-                    'a',
-                    'b',
-                    'c',
-                    'd',
-                    'e',
-                    'f'>,
-                push_hexdec,
-                finish_hexdec>;
+      rule(l, ctll::set<'0', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+        -> ctll::push<
+          create_hexdec,
+          ctll::anything,
+          push_hexdec,
+          ctll::set<
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'A',
+            'B',
+            'C',
+            'D',
+            'E',
+            'F',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f'>,
+          push_hexdec,
+          finish_hexdec>;
 
-    static constexpr auto
-        rule(m, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                ctll::anything,
-                create_number,
-                number2,
-                ctll::term<'\x7D'>,
-                make_back_reference>;
+    static constexpr auto rule(m, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::
+        push<ctll::anything, create_number, number2, ctll::term<'\x7D'>, make_back_reference>;
     static constexpr auto rule(m, ctll::term<'-'>)
-        -> ctll::push<
-            ctll::anything,
-            number,
-            ctll::term<'\x7D'>,
-            make_relative_back_reference>;
+      -> ctll::push<ctll::anything, number, ctll::term<'\x7D'>, make_relative_back_reference>;
     static constexpr auto rule(m, ctll::set<'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'>)
-        -> ctll::push<
-            ctll::anything,
-            push_name,
-            block_name2,
-            ctll::term<'\x7D'>,
-            make_back_reference>;
+      -> ctll::
+        push<ctll::anything, push_name, block_name2, ctll::term<'\x7D'>, make_back_reference>;
 
     static constexpr auto
-        rule(mod, ctll::set<'!', '$', '\x28', '\x29', ',', '-', '.', '/', '0', ':', '<', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', '\"', ']', '^', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '|', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::epsilon;
+      rule(mod, ctll::set<'!', '$', '\x28', '\x29', ',', '-', '.', '/', '0', ':', '<', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', '\"', ']', '^', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '|', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+        -> ctll::epsilon;
     static constexpr auto rule(mod, ctll::epsilon) -> ctll::epsilon;
     static constexpr auto rule(mod, _others) -> ctll::epsilon;
-    static constexpr auto rule(mod, ctll::term<'?'>)
-        -> ctll::push<ctll::anything, make_lazy>;
-    static constexpr auto rule(mod, ctll::term<'+'>)
-        -> ctll::push<ctll::anything, make_possessive>;
-    static constexpr auto rule(mod, ctll::set<'*', '\x7B', '\x7D'>)
-        -> ctll::reject;
+    static constexpr auto rule(mod, ctll::term<'?'>) -> ctll::push<ctll::anything, make_lazy>;
+    static constexpr auto rule(mod, ctll::term<'+'>) -> ctll::push<ctll::anything, make_possessive>;
+    static constexpr auto rule(mod, ctll::set<'*', '\x7B', '\x7D'>) -> ctll::reject;
 
     static constexpr auto rule(mode_switch2, ctll::term<'i'>)
-        -> ctll::push<ctll::anything, mode_case_insensitive, mode_switch2>;
+      -> ctll::push<ctll::anything, mode_case_insensitive, mode_switch2>;
     static constexpr auto rule(mode_switch2, ctll::term<'c'>)
-        -> ctll::push<ctll::anything, mode_case_sensitive, mode_switch2>;
+      -> ctll::push<ctll::anything, mode_case_sensitive, mode_switch2>;
     static constexpr auto rule(mode_switch2, ctll::term<'m'>)
-        -> ctll::push<ctll::anything, mode_multiline, mode_switch2>;
+      -> ctll::push<ctll::anything, mode_multiline, mode_switch2>;
     static constexpr auto rule(mode_switch2, ctll::term<'s'>)
-        -> ctll::push<ctll::anything, mode_singleline, mode_switch2>;
-    static constexpr auto rule(mode_switch2, ctll::term<'\x29'>)
-        -> ctll::push<ctll::anything>;
+      -> ctll::push<ctll::anything, mode_singleline, mode_switch2>;
+    static constexpr auto rule(mode_switch2, ctll::term<'\x29'>) -> ctll::push<ctll::anything>;
 
-    static constexpr auto
-        rule(n, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                ctll::anything,
-                create_number,
-                number2,
-                repeat_ab,
-                ctll::term<'\x7D'>,
-                mod>;
+    static constexpr auto rule(n, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, create_number, number2, repeat_ab, ctll::term<'\x7D'>, mod>;
     static constexpr auto rule(n, ctll::term<'\x7D'>)
-        -> ctll::push<repeat_at_least, ctll::anything, mod>;
+      -> ctll::push<repeat_at_least, ctll::anything, mod>;
 
-    static constexpr auto rule(number2, ctll::set<',', '\x7D'>)
-        -> ctll::epsilon;
-    static constexpr auto
-        rule(number2, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, push_number, number2>;
+    static constexpr auto rule(number2, ctll::set<',', '\x7D'>) -> ctll::epsilon;
+    static constexpr auto rule(number2, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_number, number2>;
 
-    static constexpr auto
-        rule(number, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, create_number, number2>;
+    static constexpr auto rule(number, ctll::set<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, create_number, number2>;
 
     static constexpr auto rule(o, ctll::set<'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'>)
-        -> ctll::push<
-            ctll::anything,
-            push_name,
-            block_name2,
-            ctll::term<'>'>,
-            content_in_capture,
-            make_capture_with_name,
-            ctll::term<'\x29'>>;
-    static constexpr auto rule(o, ctll::term<'!'>)
-        -> ctll::push<
-            ctll::anything,
-            reset_capture,
-            start_lookbehind_negative,
-            content_in_capture,
-            look_finish,
-            ctll::term<'\x29'>>;
-    static constexpr auto rule(o, ctll::term<'='>)
-        -> ctll::push<
-            ctll::anything,
-            reset_capture,
-            start_lookbehind_positive,
-            content_in_capture,
-            look_finish,
-            ctll::term<'\x29'>>;
+      -> ctll::push<
+        ctll::anything,
+        push_name,
+        block_name2,
+        ctll::term<'>'>,
+        content_in_capture,
+        make_capture_with_name,
+        ctll::term<'\x29'>>;
+    static constexpr auto rule(o, ctll::term<'!'>) -> ctll::push<
+                                                     ctll::anything,
+                                                     reset_capture,
+                                                     start_lookbehind_negative,
+                                                     content_in_capture,
+                                                     look_finish,
+                                                     ctll::term<'\x29'>>;
+    static constexpr auto rule(o, ctll::term<'='>) -> ctll::push<
+                                                     ctll::anything,
+                                                     reset_capture,
+                                                     start_lookbehind_positive,
+                                                     content_in_capture,
+                                                     look_finish,
+                                                     ctll::term<'\x29'>>;
 
-    static constexpr auto rule(p, ctll::term<'p'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'h'>,
-                                                       ctll::term<'a'>,
-                                                       class_named_alpha>;
-    static constexpr auto rule(p, ctll::term<'n'>) -> ctll::push<
-                                                       ctll::anything,
-                                                       ctll::term<'u'>,
-                                                       ctll::term<'m'>,
-                                                       class_named_alnum>;
+    static constexpr auto rule(p, ctll::term<'p'>)
+      -> ctll::push<ctll::anything, ctll::term<'h'>, ctll::term<'a'>, class_named_alpha>;
+    static constexpr auto rule(p, ctll::term<'n'>)
+      -> ctll::push<ctll::anything, ctll::term<'u'>, ctll::term<'m'>, class_named_alnum>;
 
-    static constexpr auto rule(property_name2, ctll::term<'\x7D'>)
-        -> ctll::epsilon;
+    static constexpr auto rule(property_name2, ctll::term<'\x7D'>) -> ctll::epsilon;
     static constexpr auto rule(property_name2, ctll::term<'='>)
-        -> ctll::push<ctll::anything, property_value>;
-    static constexpr auto
-        rule(property_name2, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, push_property_name, property_name2>;
+      -> ctll::push<ctll::anything, property_value>;
+    static constexpr auto rule(property_name2, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_property_name, property_name2>;
 
     static constexpr auto rule(property_name, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-        -> ctll::push<ctll::anything, push_property_name, property_name2>;
+      -> ctll::push<ctll::anything, push_property_name, property_name2>;
 
-    static constexpr auto rule(property_value2, ctll::term<'\x7D'>)
-        -> ctll::epsilon;
-    static constexpr auto
-        rule(property_value2, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, push_property_value, property_value2>;
+    static constexpr auto rule(property_value2, ctll::term<'\x7D'>) -> ctll::epsilon;
+    static constexpr auto rule(property_value2, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_property_value, property_value2>;
 
-    static constexpr auto
-        rule(property_value, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<ctll::anything, push_property_value, property_value2>;
+    static constexpr auto rule(property_value, ctll::set<'0', '.', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_property_value, property_value2>;
 
     static constexpr auto rule(range, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', '0', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', '\"', ']', '^', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-        -> ctll::epsilon;
+      -> ctll::epsilon;
     static constexpr auto rule(range, ctll::epsilon) -> ctll::epsilon;
     static constexpr auto rule(range, _others) -> ctll::epsilon;
-    static constexpr auto rule(range, ctll::term<'-'>)
-        -> ctll::push<ctll::anything, j>;
+    static constexpr auto rule(range, ctll::term<'-'>) -> ctll::push<ctll::anything, j>;
 
     static constexpr auto rule(repeat, ctll::set<'!', '$', '\x28', '\x29', ',', '-', '.', '/', '0', ':', '<', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', '\"', ']', '^', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '|', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-        -> ctll::epsilon;
+      -> ctll::epsilon;
     static constexpr auto rule(repeat, ctll::epsilon) -> ctll::epsilon;
     static constexpr auto rule(repeat, _others) -> ctll::epsilon;
     static constexpr auto rule(repeat, ctll::term<'?'>)
-        -> ctll::push<ctll::anything, make_optional, mod>;
-    static constexpr auto rule(repeat, ctll::term<'\x7B'>)
-        -> ctll::push<ctll::anything, number, b>;
+      -> ctll::push<ctll::anything, make_optional, mod>;
+    static constexpr auto rule(repeat, ctll::term<'\x7B'>) -> ctll::push<ctll::anything, number, b>;
     static constexpr auto rule(repeat, ctll::term<'+'>)
-        -> ctll::push<ctll::anything, repeat_plus, mod>;
+      -> ctll::push<ctll::anything, repeat_plus, mod>;
     static constexpr auto rule(repeat, ctll::term<'*'>)
-        -> ctll::push<ctll::anything, repeat_star, mod>;
+      -> ctll::push<ctll::anything, repeat_star, mod>;
     static constexpr auto rule(repeat, ctll::term<'\x7D'>) -> ctll::reject;
 
     static constexpr auto rule(set2a, ctll::term<']'>) -> ctll::epsilon;
     static constexpr auto rule(set2a, ctll::term<'['>)
-        -> ctll::
-            push<ctll::anything, ctll::term<':'>, i, range, set_start, set2b>;
+      -> ctll::push<ctll::anything, ctll::term<':'>, i, range, set_start, set2b>;
     static constexpr auto rule(set2a, ctll::term<'\\'>)
-        -> ctll::push<ctll::anything, f, set_start, set2b>;
-    static constexpr auto rule(set2a, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '^', '0', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, f, set_start, set2b>;
+    static constexpr auto
+      rule(set2a, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '^', '0', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
         -> ctll::push<ctll::anything, push_character, range, set_start, set2b>;
     static constexpr auto rule(set2a, _others)
-        -> ctll::push<ctll::anything, push_character, range, set_start, set2b>;
+      -> ctll::push<ctll::anything, push_character, range, set_start, set2b>;
     static constexpr auto rule(set2a, ctll::term<'-'>) -> ctll::reject;
 
     static constexpr auto rule(set2b, ctll::term<']'>) -> ctll::epsilon;
     static constexpr auto rule(set2b, ctll::term<'['>)
-        -> ctll::
-            push<ctll::anything, ctll::term<':'>, i, range, set_combine, set2b>;
+      -> ctll::push<ctll::anything, ctll::term<':'>, i, range, set_combine, set2b>;
     static constexpr auto rule(set2b, ctll::term<'\\'>)
-        -> ctll::push<ctll::anything, f, set_combine, set2b>;
-    static constexpr auto rule(set2b, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '^', '0', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-        -> ctll::
-            push<ctll::anything, push_character, range, set_combine, set2b>;
-    static constexpr auto rule(
-        set2b,
-        _others
-    ) -> ctll::push<ctll::anything, push_character, range, set_combine, set2b>;
+      -> ctll::push<ctll::anything, f, set_combine, set2b>;
+    static constexpr auto
+      rule(set2b, ctll::set<'!', '$', '\x28', '\x29', '*', '+', ',', '.', '/', ':', '<', '=', '>', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', '^', '0', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\x7B', '|', '\x7D', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+        -> ctll::push<ctll::anything, push_character, range, set_combine, set2b>;
+    static constexpr auto rule(set2b, _others)
+      -> ctll::push<ctll::anything, push_character, range, set_combine, set2b>;
     static constexpr auto rule(set2b, ctll::term<'-'>) -> ctll::reject;
 
-    static constexpr auto rule(string2, ctll::set<'\x29', '|'>)
-        -> ctll::epsilon;
+    static constexpr auto rule(string2, ctll::set<'\x29', '|'>) -> ctll::epsilon;
     static constexpr auto rule(string2, ctll::epsilon) -> ctll::epsilon;
     static constexpr auto rule(string2, ctll::term<'\\'>)
-        -> ctll::
-            push<ctll::anything, backslash, repeat, string2, make_sequence>;
+      -> ctll::push<ctll::anything, backslash, repeat, string2, make_sequence>;
     static constexpr auto rule(string2, ctll::term<'['>)
-        -> ctll::push<ctll::anything, c, repeat, string2, make_sequence>;
-    static constexpr auto rule(string2, ctll::term<'\x28'>) -> ctll::push<
-                                                                ctll::anything,
-                                                                prepare_capture,
-                                                                block,
-                                                                repeat,
-                                                                string2,
-                                                                make_sequence>;
-    static constexpr auto rule(string2, ctll::term<'^'>) -> ctll::push<
-                                                             ctll::anything,
-                                                             push_assert_begin,
-                                                             repeat,
-                                                             string2,
-                                                             make_sequence>;
-    static constexpr auto rule(string2, ctll::term<'$'>) -> ctll::push<
-                                                             ctll::anything,
-                                                             push_assert_end,
-                                                             repeat,
-                                                             string2,
-                                                             make_sequence>;
-    static constexpr auto
-        rule(string2, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
-            -> ctll::push<
-                ctll::anything,
-                push_character,
-                repeat,
-                string2,
-                make_sequence>;
-    static constexpr auto rule(
-        string2,
-        _others
-    ) -> ctll::
-          push<ctll::anything, push_character, repeat, string2, make_sequence>;
+      -> ctll::push<ctll::anything, c, repeat, string2, make_sequence>;
+    static constexpr auto rule(string2, ctll::term<'\x28'>)
+      -> ctll::push<ctll::anything, prepare_capture, block, repeat, string2, make_sequence>;
+    static constexpr auto rule(string2, ctll::term<'^'>)
+      -> ctll::push<ctll::anything, push_assert_begin, repeat, string2, make_sequence>;
+    static constexpr auto rule(string2, ctll::term<'$'>)
+      -> ctll::push<ctll::anything, push_assert_end, repeat, string2, make_sequence>;
+    static constexpr auto rule(string2, ctll::set<'!', ',', '/', ':', '<', '0', '-', '=', '>', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\"', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9'>)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, make_sequence>;
+    static constexpr auto rule(string2, _others)
+      -> ctll::push<ctll::anything, push_character, repeat, string2, make_sequence>;
     static constexpr auto rule(string2, ctll::term<'.'>)
-        -> ctll::push<
-            ctll::anything,
-            push_character_anything,
-            repeat,
-            string2,
-            make_sequence>;
-    static constexpr auto
-        rule(string2, ctll::set<'*', '+', '?', '\x7B', '\x7D'>) -> ctll::reject;
+      -> ctll::push<ctll::anything, push_character_anything, repeat, string2, make_sequence>;
+    static constexpr auto rule(string2, ctll::set<'*', '+', '?', '\x7B', '\x7D'>) -> ctll::reject;
   };
 
 } // namespace ctre
@@ -2617,18 +2283,10 @@ namespace ctre {
     constexpr flags(const flags&) = default;
     constexpr flags(flags&&)      = default;
 
-    constexpr CTRE_FORCE_INLINE flags(ctre::singleline v) noexcept {
-      set_flag(v);
-    }
-    constexpr CTRE_FORCE_INLINE flags(ctre::multiline v) noexcept {
-      set_flag(v);
-    }
-    constexpr CTRE_FORCE_INLINE flags(ctre::case_sensitive v) noexcept {
-      set_flag(v);
-    }
-    constexpr CTRE_FORCE_INLINE flags(ctre::case_insensitive v) noexcept {
-      set_flag(v);
-    }
+    constexpr CTRE_FORCE_INLINE flags(ctre::singleline v) noexcept { set_flag(v); }
+    constexpr CTRE_FORCE_INLINE flags(ctre::multiline v) noexcept { set_flag(v); }
+    constexpr CTRE_FORCE_INLINE flags(ctre::case_sensitive v) noexcept { set_flag(v); }
+    constexpr CTRE_FORCE_INLINE flags(ctre::case_insensitive v) noexcept { set_flag(v); }
 
     template <typename... Args>
     constexpr CTRE_FORCE_INLINE flags(ctll::list<Args...>) noexcept {
@@ -2641,31 +2299,24 @@ namespace ctre {
       return f;
     }
 
-    constexpr friend CTRE_FORCE_INLINE auto
-    operator+(flags f, pcre::mode_case_sensitive) noexcept {
+    constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_case_sensitive) noexcept {
       f.case_insensitive = false;
       return f;
     }
 
-    constexpr friend CTRE_FORCE_INLINE auto
-    operator+(flags f, pcre::mode_singleline) noexcept {
+    constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_singleline) noexcept {
       f.multiline = false;
       return f;
     }
 
-    constexpr friend CTRE_FORCE_INLINE auto
-    operator+(flags f, pcre::mode_multiline) noexcept {
+    constexpr friend CTRE_FORCE_INLINE auto operator+(flags f, pcre::mode_multiline) noexcept {
       f.multiline = true;
       return f;
     }
 
-    constexpr CTRE_FORCE_INLINE void set_flag(ctre::singleline) noexcept {
-      multiline = false;
-    }
+    constexpr CTRE_FORCE_INLINE void set_flag(ctre::singleline) noexcept { multiline = false; }
 
-    constexpr CTRE_FORCE_INLINE void set_flag(ctre::multiline) noexcept {
-      multiline = true;
-    }
+    constexpr CTRE_FORCE_INLINE void set_flag(ctre::multiline) noexcept { multiline = true; }
 
     constexpr CTRE_FORCE_INLINE void set_flag(ctre::case_insensitive) noexcept {
       case_insensitive = true;
@@ -2681,23 +2332,17 @@ namespace ctre {
     return f;
   }
 
-  constexpr CTRE_FORCE_INLINE auto
-  consumed_something(flags f, bool condition = true) {
-    if (condition) f.block_empty_match = false;
+  constexpr CTRE_FORCE_INLINE auto consumed_something(flags f, bool condition = true) {
+    if (condition)
+      f.block_empty_match = false;
     return f;
   }
 
-  constexpr CTRE_FORCE_INLINE bool cannot_be_empty_match(flags f) {
-    return f.block_empty_match;
-  }
+  constexpr CTRE_FORCE_INLINE bool cannot_be_empty_match(flags f) { return f.block_empty_match; }
 
-  constexpr CTRE_FORCE_INLINE bool multiline_mode(flags f) {
-    return f.multiline;
-  }
+  constexpr CTRE_FORCE_INLINE bool multiline_mode(flags f) { return f.multiline; }
 
-  constexpr CTRE_FORCE_INLINE bool is_case_insensitive(flags f) {
-    return f.case_insensitive;
-  }
+  constexpr CTRE_FORCE_INLINE bool is_case_insensitive(flags f) { return f.case_insensitive; }
 
 } // namespace ctre
 
@@ -2718,15 +2363,14 @@ namespace ctre {
 
    public:
     template <typename CharT>
-    static inline constexpr bool value =
-        decltype(test<T>(std::declval<CharT>()))();
+    static inline constexpr bool value = decltype(test<T>(std::declval<CharT>()))();
   };
 
   template <typename T>
   constexpr CTRE_FORCE_INLINE bool is_ascii_alpha(T v) {
     return (
-        (v >= static_cast<T>('a') && v <= static_cast<T>('z')) ||
-        (v >= static_cast<T>('A') && v <= static_cast<T>('Z'))
+      (v >= static_cast<T>('a') && v <= static_cast<T>('z')) ||
+      (v >= static_cast<T>('A') && v <= static_cast<T>('Z'))
     );
   }
 
@@ -2743,8 +2387,7 @@ namespace ctre {
   template <auto V>
   struct character {
     template <typename CharT>
-    CTRE_FORCE_INLINE static constexpr bool
-    match_char(CharT value, const flags& f) noexcept {
+    CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags& f) noexcept {
       if constexpr (is_ascii_alpha(V)) {
         if (is_case_insensitive(f)) {
           if (value == (V ^ static_cast<decltype(V)>(0x20))) {
@@ -2759,8 +2402,7 @@ namespace ctre {
   template <typename... Content>
   struct negative_set {
     template <typename CharT>
-    CTRE_FORCE_INLINE static constexpr bool
-    match_char(CharT value, const flags& f) noexcept {
+    CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags& f) noexcept {
       return !(Content::match_char(value, f) || ... || false);
     }
   };
@@ -2768,8 +2410,7 @@ namespace ctre {
   template <typename... Content>
   struct set {
     template <typename CharT>
-    CTRE_FORCE_INLINE static constexpr bool
-    match_char(CharT value, const flags& f) noexcept {
+    CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags& f) noexcept {
       return (Content::match_char(value, f) || ... || false);
     }
   };
@@ -2780,8 +2421,7 @@ namespace ctre {
   template <typename... Content>
   struct negate {
     template <typename CharT>
-    CTRE_FORCE_INLINE static constexpr bool
-    match_char(CharT value, const flags& f) noexcept {
+    CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags& f) noexcept {
       return !(Content::match_char(value, f) || ... || false);
     }
   };
@@ -2789,18 +2429,15 @@ namespace ctre {
   template <auto A, auto B>
   struct char_range {
     template <typename CharT>
-    CTRE_FORCE_INLINE static constexpr bool
-    match_char(CharT value, const flags& f) noexcept {
-      if constexpr (is_ascii_alpha_lowercase(A) &&
-                    is_ascii_alpha_lowercase(B)) {
+    CTRE_FORCE_INLINE static constexpr bool match_char(CharT value, const flags& f) noexcept {
+      if constexpr (is_ascii_alpha_lowercase(A) && is_ascii_alpha_lowercase(B)) {
         if (is_case_insensitive(f)) {
           if (value >= (A ^ static_cast<decltype(A)>(0x20)) &&
               value <= (B ^ static_cast<decltype(B)>(0x20))) {
             return true; //
           }
         }
-      } else if constexpr (is_ascii_alpha_uppercase(A) &&
-                           is_ascii_alpha_uppercase(B)) {
+      } else if constexpr (is_ascii_alpha_uppercase(A) && is_ascii_alpha_uppercase(B)) {
         if (is_case_insensitive(f)) {
           if (value >= (A ^ static_cast<decltype(A)>(0x20)) &&
               value <= (B ^ static_cast<decltype(B)>(0x20))) {
@@ -2812,86 +2449,81 @@ namespace ctre {
     }
   };
   using word_chars =
-      set<char_range<'A', 'Z'>,
-          char_range<'a', 'z'>,
-          char_range<'0', '9'>,
-          character<'_'>>;
+    set<char_range<'A', 'Z'>, char_range<'a', 'z'>, char_range<'0', '9'>, character<'_'>>;
 
   using space_chars = enumeration<' ', '\t', '\n', '\v', '\f', '\r'>;
 
   using vertical_space_chars = enumeration<
-      char {0x000A},     // Linefeed (LF)
-      char {0x000B},     // Vertical tab (VT)
-      char {0x000C},     // Form feed (FF)
-      char {0x000D},     // Carriage return (CR)
-      char32_t {0x0085}, // Next line (NEL)
-      char32_t {0x2028}, // Line separator
-      char32_t {0x2029}  // Paragraph separator
-      >;
+    char { 0x000A },     // Linefeed (LF)
+    char { 0x000B },     // Vertical tab (VT)
+    char { 0x000C },     // Form feed (FF)
+    char { 0x000D },     // Carriage return (CR)
+    char32_t { 0x0085 }, // Next line (NEL)
+    char32_t { 0x2028 }, // Line separator
+    char32_t { 0x2029 }  // Paragraph separator
+    >;
 
   using horizontal_space_chars = enumeration<
-      char {0x0009},     // Horizontal tab (HT)
-      char {0x0020},     // Space
-      char32_t {0x00A0}, // Non-break space
-      char32_t {0x1680}, // Ogham space mark
-      char32_t {0x180E}, // Mongolian vowel separator
-      char32_t {0x2000}, // En quad
-      char32_t {0x2001}, // Em quad
-      char32_t {0x2002}, // En space
-      char32_t {0x2003}, // Em space
-      char32_t {0x2004}, // Three-per-em space
-      char32_t {0x2005}, // Four-per-em space
-      char32_t {0x2006}, // Six-per-em space
-      char32_t {0x2007}, // Figure space
-      char32_t {0x2008}, // Punctuation space
-      char32_t {0x2009}, // Thin space
-      char32_t {0x200A}, // Hair space
-      char32_t {0x202F}, // Narrow no-break space
-      char32_t {0x205F}, // Medium mathematical space
-      char32_t {0x3000}  // Ideographic space
-      >;
+    char { 0x0009 },     // Horizontal tab (HT)
+    char { 0x0020 },     // Space
+    char32_t { 0x00A0 }, // Non-break space
+    char32_t { 0x1680 }, // Ogham space mark
+    char32_t { 0x180E }, // Mongolian vowel separator
+    char32_t { 0x2000 }, // En quad
+    char32_t { 0x2001 }, // Em quad
+    char32_t { 0x2002 }, // En space
+    char32_t { 0x2003 }, // Em space
+    char32_t { 0x2004 }, // Three-per-em space
+    char32_t { 0x2005 }, // Four-per-em space
+    char32_t { 0x2006 }, // Six-per-em space
+    char32_t { 0x2007 }, // Figure space
+    char32_t { 0x2008 }, // Punctuation space
+    char32_t { 0x2009 }, // Thin space
+    char32_t { 0x200A }, // Hair space
+    char32_t { 0x202F }, // Narrow no-break space
+    char32_t { 0x205F }, // Medium mathematical space
+    char32_t { 0x3000 }  // Ideographic space
+    >;
 
-  using alphanum_chars =
-      set<char_range<'A', 'Z'>, char_range<'a', 'z'>, char_range<'0', '9'>>;
+  using alphanum_chars = set<char_range<'A', 'Z'>, char_range<'a', 'z'>, char_range<'0', '9'>>;
 
   using alpha_chars = set<char_range<'A', 'Z'>, char_range<'a', 'z'>>;
 
-  using xdigit_chars =
-      set<char_range<'A', 'F'>, char_range<'a', 'f'>, char_range<'0', '9'>>;
+  using xdigit_chars = set<char_range<'A', 'F'>, char_range<'a', 'f'>, char_range<'0', '9'>>;
 
   using punct_chars = enumeration<
-      '!',
-      '"',
-      '#',
-      '$',
-      '%',
-      '&',
-      '\'',
-      '(',
-      ')',
-      '*',
-      '+',
-      ',',
-      '-',
-      '.',
-      '/',
-      ':',
-      ';',
-      '<',
-      '=',
-      '>',
-      '?',
-      '@',
-      '[',
-      '\\',
-      ']',
-      '^',
-      '_',
-      '`',
-      '{',
-      '|',
-      '}',
-      '~'>;
+    '!',
+    '"',
+    '#',
+    '$',
+    '%',
+    '&',
+    '\'',
+    '(',
+    ')',
+    '*',
+    '+',
+    ',',
+    '-',
+    '.',
+    '/',
+    ':',
+    ';',
+    '<',
+    '=',
+    '>',
+    '?',
+    '@',
+    '[',
+    '\\',
+    ']',
+    '^',
+    '_',
+    '`',
+    '{',
+    '|',
+    '}',
+    '~'>;
 
   using digit_chars = char_range<'0', '9'>;
 
@@ -3083,7 +2715,7 @@ namespace uni {
 
   namespace detail {
     enum class binary_prop;
-    constexpr int propnamecomp(std::string_view sa, std::string_view sb);
+    constexpr int         propnamecomp(std::string_view sa, std::string_view sb);
     constexpr binary_prop binary_prop_from_string(std::string_view s);
 
     template <binary_prop p>
@@ -3126,11 +2758,9 @@ namespace ctre {
   struct property;
 
   template <auto Type>
-  using make_binary_property =
-      binary_property<std::remove_const_t<decltype(Type)>, Type>;
+  using make_binary_property = binary_property<std::remove_const_t<decltype(Type)>, Type>;
   template <auto Type, auto Value>
-  using make_property =
-      property<std::remove_const_t<decltype(Type)>, Type, Value>;
+  using make_property = property<std::remove_const_t<decltype(Type)>, Type, Value>;
 
   // unicode TS#18 level 1.2 general_category
   template <uni::detail::binary_prop Property>
@@ -3160,7 +2790,8 @@ namespace ctre {
     template <typename CharT>
     inline static constexpr bool match_char(CharT c, const flags&) noexcept {
       for (uni::script sc : uni::cp_script_extensions(c)) {
-        if (sc == Script) return true;
+        if (sc == Script)
+          return true;
       }
       return false;
     }
@@ -3186,8 +2817,7 @@ namespace ctre {
 
   template <typename = void> // Make it always a template as propnamecomp isn't
                              // defined yet
-  constexpr property_type property_type_from_name(std::string_view str
-  ) noexcept {
+  constexpr property_type property_type_from_name(std::string_view str) noexcept {
     using namespace std::string_view_literals;
     if (uni::detail::propnamecomp(str, "script"sv) == 0 ||
         uni::detail::propnamecomp(str, "sc"sv) == 0) {
@@ -3214,9 +2844,8 @@ namespace ctre {
 
   template <auto... Name>
   struct property_builder {
-    static constexpr char name[sizeof...(Name)] {static_cast<char>(Name)...};
-    static constexpr property_type type =
-        property_type_from_name(get_string_view(name));
+    static constexpr char          name[sizeof...(Name)] { static_cast<char>(Name)... };
+    static constexpr property_type type = property_type_from_name(get_string_view(name));
 
     using helper = property_type_builder<type>;
 
@@ -3232,9 +2861,8 @@ namespace ctre {
   struct property_type_builder<property_type::script> {
     template <auto... Value>
     static constexpr auto get() {
-      constexpr char value[sizeof...(Value)] {static_cast<char>(Value)...};
-      constexpr auto sc =
-          uni::detail::script_from_string(get_string_view(value));
+      constexpr char value[sizeof...(Value)] { static_cast<char>(Value)... };
+      constexpr auto sc = uni::detail::script_from_string(get_string_view(value));
       if constexpr (uni::detail::is_unknown(sc)) {
         return ctll::reject {};
       } else {
@@ -3247,9 +2875,8 @@ namespace ctre {
   struct property_type_builder<property_type::script_extension> {
     template <auto... Value>
     static constexpr auto get() {
-      constexpr char value[sizeof...(Value)] {static_cast<char>(Value)...};
-      constexpr auto sc =
-          uni::detail::script_from_string(get_string_view(value));
+      constexpr char value[sizeof...(Value)] { static_cast<char>(Value)... };
+      constexpr auto sc = uni::detail::script_from_string(get_string_view(value));
       if constexpr (uni::detail::is_unknown(sc)) {
         return ctll::reject {};
       } else {
@@ -3262,7 +2889,7 @@ namespace ctre {
   struct property_type_builder<property_type::age> {
     template <auto... Value>
     static constexpr auto get() {
-      constexpr char value[sizeof...(Value)] {static_cast<char>(Value)...};
+      constexpr char value[sizeof...(Value)] { static_cast<char>(Value)... };
       constexpr auto age = uni::detail::age_from_string(get_string_view(value));
       if constexpr (uni::detail::is_unassigned(age)) {
         return ctll::reject {};
@@ -3276,9 +2903,8 @@ namespace ctre {
   struct property_type_builder<property_type::block> {
     template <auto... Value>
     static constexpr auto get() {
-      constexpr char value[sizeof...(Value)] {static_cast<char>(Value)...};
-      constexpr auto block =
-          uni::detail::block_from_string(get_string_view(value));
+      constexpr char value[sizeof...(Value)] { static_cast<char>(Value)... };
+      constexpr auto block = uni::detail::block_from_string(get_string_view(value));
       if constexpr (uni::detail::is_unknown(block)) {
         return ctll::reject {};
       } else {
@@ -3298,13 +2924,13 @@ namespace ctre {
   auto convert_to_capture(ctll::list<Content...>) -> capture<Index, Content...>;
   template <size_t Index, typename Name, typename... Content>
   auto convert_to_named_capture(ctll::list<Content...>)
-      -> capture_with_name<Index, Name, Content...>;
+    -> capture_with_name<Index, Name, Content...>;
   template <
-      template <size_t, size_t, typename...>
-      typename CycleType,
-      size_t A,
-      size_t B,
-      typename... Content>
+    template <size_t, size_t, typename...>
+    typename CycleType,
+    size_t A,
+    size_t B,
+    typename... Content>
   auto convert_to_repeat(ctll::list<Content...>) -> CycleType<A, B, Content...>;
   template <template <typename...> typename ListType, typename... Content>
   auto convert_to_basic_list(ctll::list<Content...>) -> ListType<Content...>;
@@ -3312,8 +2938,7 @@ namespace ctre {
   template <auto V>
   struct rotate_value {
     template <auto... Vs>
-    friend constexpr auto operator+(string<Vs...>, rotate_value<V>) noexcept
-        -> string<V, Vs...> {
+    friend constexpr auto operator+(string<Vs...>, rotate_value<V>) noexcept -> string<V, Vs...> {
       return {};
     }
   };
@@ -3361,74 +2986,68 @@ namespace ctre {
 
     template <size_t a, size_t b, typename... Content>
     static auto rotate(repeat<a, b, Content...>)
-        -> decltype(ctre::convert_to_repeat<repeat, a, b>(
-            ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
-        ));
+      -> decltype(ctre::convert_to_repeat<repeat, a, b>(
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+      ));
     template <size_t a, size_t b, typename... Content>
     static auto rotate(lazy_repeat<a, b, Content...>)
-        -> decltype(ctre::convert_to_repeat<lazy_repeat, a, b>(
-            ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
-        ));
+      -> decltype(ctre::convert_to_repeat<lazy_repeat, a, b>(
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+      ));
     template <size_t a, size_t b, typename... Content>
     static auto rotate(possessive_repeat<a, b, Content...>)
-        -> decltype(ctre::convert_to_repeat<possessive_repeat, a, b>(
-            ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
-        ));
+      -> decltype(ctre::convert_to_repeat<possessive_repeat, a, b>(
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+      ));
 
     template <size_t Index, typename... Content>
     static auto rotate(capture<Index, Content...>) {
       return ctre::convert_to_capture<Index>(
-          ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
       );
     }
 
     template <size_t Index, typename Name, typename... Content>
     static auto rotate(capture_with_name<Index, Name, Content...>) {
       return ctre::convert_to_named_capture<Index, Name>(
-          ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
       );
     }
 
     template <size_t Index>
     static auto rotate(back_reference<Index>) -> back_reference<Index>;
     template <typename Name>
-    static auto rotate(back_reference_with_name<Name>)
-        -> back_reference_with_name<Name>;
+    static auto rotate(back_reference_with_name<Name>) -> back_reference_with_name<Name>;
 
     template <typename... Content>
     static auto rotate(look_start<Content...>) -> look_start<Content...>;
 
     template <auto... Str>
-    static auto rotate(string<Str...>)
-        -> decltype((string<> {} + ... + rotate_value<Str> {}));
+    static auto rotate(string<Str...>) -> decltype((string<> {} + ... + rotate_value<Str> {}));
 
     template <typename... Content>
     static auto rotate(sequence<Content...>) {
       return ctre::convert_to_basic_list<sequence>(
-          ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
       );
     }
 
     // we don't rotate lookaheads
     template <typename... Content>
-    static auto rotate(lookahead_positive<Content...>)
-        -> lookahead_positive<Content...>;
+    static auto rotate(lookahead_positive<Content...>) -> lookahead_positive<Content...>;
     template <typename... Content>
-    static auto rotate(lookahead_negative<Content...>)
-        -> lookahead_negative<Content...>;
+    static auto rotate(lookahead_negative<Content...>) -> lookahead_negative<Content...>;
     template <typename... Content>
-    static auto rotate(lookbehind_positive<Content...>)
-        -> lookbehind_positive<Content...>;
+    static auto rotate(lookbehind_positive<Content...>) -> lookbehind_positive<Content...>;
     template <typename... Content>
-    static auto rotate(lookbehind_negative<Content...>)
-        -> lookbehind_negative<Content...>;
+    static auto rotate(lookbehind_negative<Content...>) -> lookbehind_negative<Content...>;
 
     static auto rotate(atomic_start) -> atomic_start;
 
     template <typename... Content>
     static auto rotate(atomic_group<Content...>) {
       return ctre::convert_to_basic_list<atomic_group>(
-          ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
+        ctll::rotate(ctll::list<decltype(rotate(Content {}))...> {})
       );
     }
 
@@ -3457,29 +3076,24 @@ namespace ctre {
 
   template <auto... Name>
   struct id {
-    static constexpr auto name =
-        ctll::fixed_string<sizeof...(Name)> {{Name...}};
+    static constexpr auto name = ctll::fixed_string<sizeof...(Name)> { { Name... } };
 
-    friend constexpr auto operator==(id<Name...>, id<Name...>) noexcept
-        -> std::true_type {
+    friend constexpr auto operator==(id<Name...>, id<Name...>) noexcept -> std::true_type {
       return {};
     }
 
     template <auto... Other>
-    friend constexpr auto operator==(id<Name...>, id<Other...>) noexcept
-        -> std::false_type {
+    friend constexpr auto operator==(id<Name...>, id<Other...>) noexcept -> std::false_type {
       return {};
     }
 
     template <typename T>
-    friend constexpr auto operator==(id<Name...>, T) noexcept
-        -> std::false_type {
+    friend constexpr auto operator==(id<Name...>, T) noexcept -> std::false_type {
       return {};
     }
 
     template <typename T>
-    friend constexpr auto operator==(T, id<Name...>) noexcept
-        -> std::false_type {
+    friend constexpr auto operator==(T, id<Name...>) noexcept -> std::false_type {
       return {};
     }
   };
@@ -3499,9 +3113,9 @@ namespace ctre {
   };
 
   template <
-      typename Stack      = ctll::list<>,
-      typename Parameters = pcre_parameters<0>,
-      typename Mode       = ctll::list<>>
+    typename Stack      = ctll::list<>,
+    typename Parameters = pcre_parameters<0>,
+    typename Mode       = ctll::list<>>
   struct pcre_context {
     using stack_type                        = Stack;
     using parameters_type                   = Parameters;
@@ -3516,7 +3130,7 @@ namespace ctre {
 
   template <typename... Content, typename Parameters>
   pcre_context(ctll::list<Content...>, Parameters)
-      -> pcre_context<ctll::list<Content...>, Parameters>;
+    -> pcre_context<ctll::list<Content...>, Parameters>;
 
   template <size_t Value>
   struct number {};
@@ -3532,65 +3146,56 @@ namespace ctre {
     // push_assert_begin
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_assert_begin,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_assert_begin,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(assert_line_begin(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(assert_line_begin(), subject.stack),
+                            subject.parameters };
     }
 
     // push_assert_end
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_assert_end,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_assert_end,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(assert_line_end(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(assert_line_end(), subject.stack),
+                            subject.parameters };
     }
 
     // push_assert_begin
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_assert_subject_begin,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_assert_subject_begin,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(assert_subject_begin(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(assert_subject_begin(), subject.stack),
+                            subject.parameters };
     }
 
     // push_assert_subject_end
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_assert_subject_end,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_assert_subject_end,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(assert_subject_end(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(assert_subject_end(), subject.stack),
+                            subject.parameters };
     }
 
     // push_assert_subject_end_with_lineend
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_assert_subject_end_with_lineend,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_assert_subject_end_with_lineend,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(assert_subject_end_line(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(assert_subject_end_line(), subject.stack),
+                            subject.parameters };
     }
 
 #endif
@@ -3602,28 +3207,22 @@ namespace ctre {
     template <auto V, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::start_atomic, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<atomic_start, Ts...>(), pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<atomic_start, Ts...>(), pcre_parameters<Counter>() };
     }
 
     // atomic
     template <auto V, typename Atomic, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::make_atomic, ctll::term<V>, pcre_context<ctll::list<Atomic, atomic_start, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<atomic_group<Atomic>, Ts...>(), pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<atomic_group<Atomic>, Ts...>(), pcre_parameters<Counter>() };
     }
 
     // atomic sequence
     template <auto V, typename... Atomic, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::make_atomic, ctll::term<V>, pcre_context<ctll::list<sequence<Atomic...>, atomic_start, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<atomic_group<Atomic...>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<atomic_group<Atomic...>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
 #endif
@@ -3636,10 +3235,8 @@ namespace ctre {
     static constexpr auto
     apply(pcre::make_back_reference, ctll::term<V>, pcre_context<ctll::list<id<Str...>, Ts...>, pcre_parameters<Counter>>) {
       return pcre_context {
-          ctll::push_front(
-              back_reference_with_name<id<Str...>>(), ctll::list<Ts...>()
-          ),
-          pcre_parameters<Counter>()
+        ctll::push_front(back_reference_with_name<id<Str...>>(), ctll::list<Ts...>()),
+        pcre_parameters<Counter>()
       };
     }
 
@@ -3652,10 +3249,8 @@ namespace ctre {
       if constexpr (Counter < Id) {
         return ctll::reject {};
       } else {
-        return pcre_context {
-            ctll::push_front(back_reference<Id>(), ctll::list<Ts...>()),
-            pcre_parameters<Counter>()
-        };
+        return pcre_context { ctll::push_front(back_reference<Id>(), ctll::list<Ts...>()),
+                              pcre_parameters<Counter>() };
       }
     }
 
@@ -3669,12 +3264,8 @@ namespace ctre {
         return ctll::reject {};
       } else {
         constexpr size_t absolute_id = (Counter + 1) - Id;
-        return pcre_context {
-            ctll::push_front(
-                back_reference<absolute_id>(), ctll::list<Ts...>()
-            ),
-            pcre_parameters<Counter>()
-        };
+        return pcre_context { ctll::push_front(back_reference<absolute_id>(), ctll::list<Ts...>()),
+                              pcre_parameters<Counter>() };
       }
     }
 
@@ -3686,27 +3277,23 @@ namespace ctre {
     // push_word_boundary
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_word_boundary,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_word_boundary,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(boundary<word_chars>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(boundary<word_chars>(), subject.stack),
+                            subject.parameters };
     }
 
     // push_not_word_boundary
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_not_word_boundary,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_not_word_boundary,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(boundary<negative_set<word_chars>>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(boundary<negative_set<word_chars>>(), subject.stack),
+                            subject.parameters };
     }
 
 #endif
@@ -3718,98 +3305,63 @@ namespace ctre {
     template <auto V, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::prepare_capture, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::push_front(capture_id<Counter + 1>(), ctll::list<Ts...>()),
-          pcre_parameters<Counter + 1>()
-      };
+      return pcre_context { ctll::push_front(capture_id<Counter + 1>(), ctll::list<Ts...>()),
+                            pcre_parameters<Counter + 1>() };
     }
 
     // reset_capture
     template <auto V, typename... Ts, size_t Id, size_t Counter>
     static constexpr auto
     apply(pcre::reset_capture, ctll::term<V>, pcre_context<ctll::list<capture_id<Id>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {ctll::list<Ts...>(), pcre_parameters<Counter - 1>()};
+      return pcre_context { ctll::list<Ts...>(), pcre_parameters<Counter - 1>() };
     }
 
     // capture
     template <auto V, typename A, size_t Id, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<A, capture_id<Id>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::push_front(capture<Id, A>(), ctll::list<Ts...>()),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::push_front(capture<Id, A>(), ctll::list<Ts...>()),
+                            pcre_parameters<Counter>() };
     }
     // capture (sequence)
-    template <
-        auto V,
-        typename... Content,
-        size_t Id,
-        typename... Ts,
-        size_t Counter>
+    template <auto V, typename... Content, size_t Id, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, capture_id<Id>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::push_front(capture<Id, Content...>(), ctll::list<Ts...>()),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::push_front(capture<Id, Content...>(), ctll::list<Ts...>()),
+                            pcre_parameters<Counter>() };
     }
     // push_name
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::push_name,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(id<V>(), subject.stack), subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::push_name, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(id<V>(), subject.stack), subject.parameters };
     }
     // push_name (concat)
     template <auto... Str, auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_name,
-        ctll::term<V>,
-        pcre_context<ctll::list<id<Str...>, Ts...>, Parameters> subject
+      pcre::push_name,
+      ctll::term<V>,
+      pcre_context<ctll::list<id<Str...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(id<Str..., V>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(id<Str..., V>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // capture with name
-    template <
-        auto... Str,
-        auto V,
-        typename A,
-        size_t Id,
-        typename... Ts,
-        size_t Counter>
+    template <auto... Str, auto V, typename A, size_t Id, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<A, id<Str...>, capture_id<Id>, Ts...>, pcre_parameters<Counter>>) {
       return pcre_context {
-          ctll::push_front(
-              capture_with_name<Id, id<Str...>, A>(), ctll::list<Ts...>()
-          ),
-          pcre_parameters<Counter>()
+        ctll::push_front(capture_with_name<Id, id<Str...>, A>(), ctll::list<Ts...>()),
+        pcre_parameters<Counter>()
       };
     }
     // capture with name (sequence)
-    template <
-        auto... Str,
-        auto V,
-        typename... Content,
-        size_t Id,
-        typename... Ts,
-        size_t Counter>
+    template <auto... Str, auto V, typename... Content, size_t Id, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, id<Str...>, capture_id<Id>, Ts...>, pcre_parameters<Counter>>) {
       return pcre_context {
-          ctll::push_front(
-              capture_with_name<Id, id<Str...>, Content...>(),
-              ctll::list<Ts...>()
-          ),
-          pcre_parameters<Counter>()
+        ctll::push_front(capture_with_name<Id, id<Str...>, Content...>(), ctll::list<Ts...>()),
+        pcre_parameters<Counter>()
       };
     }
 
@@ -3821,107 +3373,90 @@ namespace ctre {
     // push character
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<V>(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<V>(), subject.stack), subject.parameters };
     }
     // push_any_character
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_anything,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_anything,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(any(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(any(), subject.stack), subject.parameters };
     }
     // character_alarm
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_alarm,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_alarm,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\x07'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\x07'>(), subject.stack),
+                            subject.parameters };
     }
     // character_escape
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_escape,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_escape,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\x14'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\x14'>(), subject.stack),
+                            subject.parameters };
     }
     // character_formfeed
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_formfeed,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_formfeed,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\x0C'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\x0C'>(), subject.stack),
+                            subject.parameters };
     }
     // push_character_newline
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_newline,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_newline,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\x0A'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\x0A'>(), subject.stack),
+                            subject.parameters };
     }
     // push_character_null
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_null,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_null,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\0'>(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\0'>(), subject.stack),
+                            subject.parameters };
     }
     // push_character_return_carriage
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_return_carriage,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_return_carriage,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\x0D'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\x0D'>(), subject.stack),
+                            subject.parameters };
     }
     // push_character_tab
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_character_tab,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_character_tab,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(character<'\x09'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(character<'\x09'>(), subject.stack),
+                            subject.parameters };
     }
 
 #endif
@@ -3931,153 +3466,112 @@ namespace ctre {
 
     // class_digit
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::class_digit,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(ctre::set<ctre::digit_chars>(), subject.stack),
-          subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::class_digit, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(ctre::set<ctre::digit_chars>(), subject.stack),
+                            subject.parameters };
     }
     // class_non_digit
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_nondigit,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_nondigit,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::negative_set<ctre::digit_chars>(), subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(ctre::negative_set<ctre::digit_chars>(), subject.stack), subject.parameters
       };
     }
     // class_space
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::class_space,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(ctre::set<ctre::space_chars>(), subject.stack),
-          subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::class_space, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(ctre::set<ctre::space_chars>(), subject.stack),
+                            subject.parameters };
     }
     // class_nonspace
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_nonspace,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_nonspace,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::negative_set<ctre::space_chars>(), subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(ctre::negative_set<ctre::space_chars>(), subject.stack), subject.parameters
       };
     }
 
     // class_horizontal_space
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_horizontal_space,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_horizontal_space,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::set<ctre::horizontal_space_chars>(), subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(ctre::set<ctre::horizontal_space_chars>(), subject.stack),
+        subject.parameters
       };
     }
     // class_horizontal_nonspace
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_non_horizontal_space,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_non_horizontal_space,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::negative_set<ctre::horizontal_space_chars>(), subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(ctre::negative_set<ctre::horizontal_space_chars>(), subject.stack),
+        subject.parameters
       };
     }
     // class_vertical_space
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_vertical_space,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_vertical_space,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::set<ctre::vertical_space_chars>(), subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(ctre::set<ctre::vertical_space_chars>(), subject.stack), subject.parameters
       };
     }
     // class_vertical_nonspace
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_non_vertical_space,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_non_vertical_space,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::negative_set<ctre::vertical_space_chars>(), subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(ctre::negative_set<ctre::vertical_space_chars>(), subject.stack),
+        subject.parameters
       };
     }
 
     // class_word
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::class_word,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(ctre::set<ctre::word_chars>(), subject.stack),
-          subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::class_word, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(ctre::set<ctre::word_chars>(), subject.stack),
+                            subject.parameters };
     }
     // class_nonword
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::class_nonword,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(
-              ctre::negative_set<ctre::word_chars>(), subject.stack
-          ),
-          subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::class_nonword, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(ctre::negative_set<ctre::word_chars>(), subject.stack),
+                            subject.parameters };
     }
     // class_nonnewline
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_nonnewline,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_nonnewline,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(
-              ctre::negative_set<character<'\n'>>(), subject.stack
-          ),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::negative_set<character<'\n'>>(), subject.stack),
+                            subject.parameters };
     }
 
 #endif
@@ -4092,36 +3586,19 @@ namespace ctre {
         return 0;
     }
 
-    template <
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content>
+    template <size_t MinA, size_t MaxA, size_t MinB, size_t MaxB, typename... Content>
     static constexpr auto
     combine_repeat(repeat<MinA, MaxA, Content...>, repeat<MinB, MaxB, Content...>) {
-      return repeat<
-          MinA + MinB, combine_max_repeat_length(MaxA, MaxB), Content...>();
+      return repeat<MinA + MinB, combine_max_repeat_length(MaxA, MaxB), Content...>();
     }
 
-    template <
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content>
+    template <size_t MinA, size_t MaxA, size_t MinB, size_t MaxB, typename... Content>
     static constexpr auto
     combine_repeat(lazy_repeat<MinA, MaxA, Content...>, lazy_repeat<MinB, MaxB, Content...>) {
-      return lazy_repeat<
-          MinA + MinB, combine_max_repeat_length(MaxA, MaxB), Content...>();
+      return lazy_repeat<MinA + MinB, combine_max_repeat_length(MaxA, MaxB), Content...>();
     }
 
-    template <
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content>
+    template <size_t MinA, size_t MaxA, size_t MinB, size_t MaxB, typename... Content>
     static constexpr auto
     combine_repeat(possessive_repeat<MinA, MaxA, Content...>, possessive_repeat<MinB, MaxB, Content...>) {
       [[maybe_unused]] constexpr bool first_is_unbounded  = (MaxA == 0);
@@ -4135,203 +3612,180 @@ namespace ctre {
       } else if constexpr (first_is_unbounded) {
         return possessive_repeat<MinA, MaxA, Content...>();
       } else if constexpr (second_can_be_empty) {
-        return possessive_repeat<
-            MinA, combine_max_repeat_length(MaxA, MaxB), Content...>();
+        return possessive_repeat<MinA, combine_max_repeat_length(MaxA, MaxB), Content...>();
       } else {
-        return possessive_repeat<
-            MaxA + MinB, combine_max_repeat_length(MaxA, MaxB), Content...>();
+        return possessive_repeat<MaxA + MinB, combine_max_repeat_length(MaxA, MaxB), Content...>();
       }
     }
 
     // concat repeat sequences
     template <
-        auto   V,
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content,
-        typename... Ts,
-        typename Parameters>
+      auto   V,
+      size_t MinA,
+      size_t MaxA,
+      size_t MinB,
+      size_t MaxB,
+      typename... Content,
+      typename... Ts,
+      typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<
-                repeat<MinB, MaxB, Content...>,
-                repeat<MinA, MaxA, Content...>,
-                Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<
+        ctll::list<repeat<MinB, MaxB, Content...>, repeat<MinA, MaxA, Content...>, Ts...>,
+        Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              combine_repeat(
-                  repeat<MinA, MaxA, Content...>(),
-                  repeat<MinB, MaxB, Content...>()
-              ),
-              ctll::list<Ts...>()
-          ),
-          subject.parameters
+        ctll::push_front(
+          combine_repeat(repeat<MinA, MaxA, Content...>(), repeat<MinB, MaxB, Content...>()),
+          ctll::list<Ts...>()
+        ),
+        subject.parameters
       };
     }
 
     // concat lazy repeat sequences
     template <
-        auto   V,
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content,
-        typename... Ts,
-        typename Parameters>
+      auto   V,
+      size_t MinA,
+      size_t MaxA,
+      size_t MinB,
+      size_t MaxB,
+      typename... Content,
+      typename... Ts,
+      typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<
-                lazy_repeat<MinB, MaxB, Content...>,
-                lazy_repeat<MinA, MaxA, Content...>,
-                Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<
+        ctll::list<lazy_repeat<MinB, MaxB, Content...>, lazy_repeat<MinA, MaxA, Content...>, Ts...>,
+        Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(
-              combine_repeat(
-                  lazy_repeat<MinA, MaxA, Content...>(),
-                  lazy_repeat<MinB, MaxB, Content...>()
-              ),
-              ctll::list<Ts...>()
-          ),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(
+                              combine_repeat(
+                                lazy_repeat<MinA, MaxA, Content...>(),
+                                lazy_repeat<MinB, MaxB, Content...>()
+                              ),
+                              ctll::list<Ts...>()
+                            ),
+                            subject.parameters };
     }
 
     // concat possessive repeat seqeunces
     template <
-        auto   V,
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content,
-        typename... Ts,
-        typename Parameters>
+      auto   V,
+      size_t MinA,
+      size_t MaxA,
+      size_t MinB,
+      size_t MaxB,
+      typename... Content,
+      typename... Ts,
+      typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<
-                possessive_repeat<MinB, MaxB, Content...>,
-                possessive_repeat<MinA, MaxA, Content...>,
-                Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<
+        ctll::list<
+          possessive_repeat<MinB, MaxB, Content...>,
+          possessive_repeat<MinA, MaxA, Content...>,
+          Ts...>,
+        Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(
-              combine_repeat(
-                  possessive_repeat<MinA, MaxA, Content...>(),
-                  possessive_repeat<MinB, MaxB, Content...>()
-              ),
-              ctll::list<Ts...>()
-          ),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(
+                              combine_repeat(
+                                possessive_repeat<MinA, MaxA, Content...>(),
+                                possessive_repeat<MinB, MaxB, Content...>()
+                              ),
+                              ctll::list<Ts...>()
+                            ),
+                            subject.parameters };
     }
 
     // concat repeat sequences into sequence
     template <
-        auto   V,
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content,
-        typename... As,
-        typename... Ts,
-        typename Parameters>
+      auto   V,
+      size_t MinA,
+      size_t MaxA,
+      size_t MinB,
+      size_t MaxB,
+      typename... Content,
+      typename... As,
+      typename... Ts,
+      typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<
-                sequence<repeat<MinB, MaxB, Content...>, As...>,
-                repeat<MinA, MaxA, Content...>,
-                Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<
+        ctll::list<
+          sequence<repeat<MinB, MaxB, Content...>, As...>,
+          repeat<MinA, MaxA, Content...>,
+          Ts...>,
+        Parameters> subject
     ) {
-      using result = decltype(combine_repeat(
-          repeat<MinB, MaxB, Content...>(), repeat<MinA, MaxA, Content...>()
-      ));
+      using result =
+        decltype(combine_repeat(repeat<MinB, MaxB, Content...>(), repeat<MinA, MaxA, Content...>())
+        );
 
-      return pcre_context {
-          ctll::push_front(sequence<result, As...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(sequence<result, As...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // concat lazy repeat sequences into sequence
     template <
-        auto   V,
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content,
-        typename... As,
-        typename... Ts,
-        typename Parameters>
+      auto   V,
+      size_t MinA,
+      size_t MaxA,
+      size_t MinB,
+      size_t MaxB,
+      typename... Content,
+      typename... As,
+      typename... Ts,
+      typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<
-                sequence<lazy_repeat<MinB, MaxB, Content...>, As...>,
-                lazy_repeat<MinA, MaxA, Content...>,
-                Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<
+        ctll::list<
+          sequence<lazy_repeat<MinB, MaxB, Content...>, As...>,
+          lazy_repeat<MinA, MaxA, Content...>,
+          Ts...>,
+        Parameters> subject
     ) {
       using result = decltype(combine_repeat(
-          lazy_repeat<MinB, MaxB, Content...>(),
-          lazy_repeat<MinA, MaxA, Content...>()
+        lazy_repeat<MinB, MaxB, Content...>(), lazy_repeat<MinA, MaxA, Content...>()
       ));
 
-      return pcre_context {
-          ctll::push_front(sequence<result, As...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(sequence<result, As...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // concat possessive repeat sequences into sequence
     template <
-        auto   V,
-        size_t MinA,
-        size_t MaxA,
-        size_t MinB,
-        size_t MaxB,
-        typename... Content,
-        typename... As,
-        typename... Ts,
-        typename Parameters>
+      auto   V,
+      size_t MinA,
+      size_t MaxA,
+      size_t MinB,
+      size_t MaxB,
+      typename... Content,
+      typename... As,
+      typename... Ts,
+      typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<
-                sequence<possessive_repeat<MinB, MaxB, Content...>, As...>,
-                possessive_repeat<MinA, MaxA, Content...>,
-                Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<
+        ctll::list<
+          sequence<possessive_repeat<MinB, MaxB, Content...>, As...>,
+          possessive_repeat<MinA, MaxA, Content...>,
+          Ts...>,
+        Parameters> subject
     ) {
       using result = decltype(combine_repeat(
-          possessive_repeat<MinB, MaxB, Content...>(),
-          possessive_repeat<MinA, MaxA, Content...>()
+        possessive_repeat<MinB, MaxB, Content...>(), possessive_repeat<MinA, MaxA, Content...>()
       ));
 
-      return pcre_context {
-          ctll::push_front(sequence<result, As...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(sequence<result, As...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
 #endif
@@ -4341,64 +3795,49 @@ namespace ctre {
 
     // hexdec character support (seed)
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::create_hexdec,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(number<0ull>(), subject.stack), subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::create_hexdec, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(number<0ull>(), subject.stack), subject.parameters };
     }
     // hexdec character support (push value)
     template <auto V, size_t N, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_hexdec,
-        ctll::term<V>,
-        pcre_context<ctll::list<number<N>, Ts...>, Parameters> subject
+      pcre::push_hexdec,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<N>, Ts...>, Parameters> subject
     ) {
       constexpr auto previous = N << 4ull;
       if constexpr (V >= 'a' && V <= 'f') {
         return pcre_context {
-            ctll::push_front(
-                number<(previous + (V - 'a' + 10))>(), ctll::list<Ts...>()
-            ),
-            subject.parameters
+          ctll::push_front(number<(previous + (V - 'a' + 10))>(), ctll::list<Ts...>()),
+          subject.parameters
         };
       } else if constexpr (V >= 'A' && V <= 'F') {
         return pcre_context {
-            ctll::push_front(
-                number<(previous + (V - 'A' + 10))>(), ctll::list<Ts...>()
-            ),
-            subject.parameters
+          ctll::push_front(number<(previous + (V - 'A' + 10))>(), ctll::list<Ts...>()),
+          subject.parameters
         };
       } else {
         return pcre_context {
-            ctll::push_front(
-                number<(previous + (V - '0'))>(), ctll::list<Ts...>()
-            ),
-            subject.parameters
+          ctll::push_front(number<(previous + (V - '0'))>(), ctll::list<Ts...>()),
+          subject.parameters
         };
       }
     }
     // hexdec character support (convert to character)
     template <auto V, size_t N, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::finish_hexdec,
-        ctll::term<V>,
-        pcre_context<ctll::list<number<N>, Ts...>, Parameters> subject
+      pcre::finish_hexdec,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<N>, Ts...>, Parameters> subject
     ) {
       constexpr size_t max_char = (std::numeric_limits<char>::max)();
       if constexpr (N <= max_char) {
-        return pcre_context {
-            ctll::push_front(character<char {N}>(), ctll::list<Ts...>()),
-            subject.parameters
-        };
+        return pcre_context { ctll::push_front(character<char { N }>(), ctll::list<Ts...>()),
+                              subject.parameters };
       } else {
-        return pcre_context {
-            ctll::push_front(character<char32_t {N}>(), ctll::list<Ts...>()),
-            subject.parameters
-        };
+        return pcre_context { ctll::push_front(character<char32_t { N }>(), ctll::list<Ts...>()),
+                              subject.parameters };
       }
     }
 
@@ -4411,60 +3850,48 @@ namespace ctre {
     template <auto V, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::start_lookahead_positive, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<look_start<lookahead_positive<>>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<look_start<lookahead_positive<>>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookahead positive end
     template <auto V, typename Look, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<Look, look_start<lookahead_positive<>>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<lookahead_positive<Look>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<lookahead_positive<Look>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookahead positive end (sequence)
     template <auto V, typename... Look, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<ctre::sequence<Look...>, look_start<lookahead_positive<>>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<lookahead_positive<Look...>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<lookahead_positive<Look...>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookahead negative start
     template <auto V, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::start_lookahead_negative, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<look_start<lookahead_negative<>>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<look_start<lookahead_negative<>>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookahead negative end
     template <auto V, typename Look, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<Look, look_start<lookahead_negative<>>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<lookahead_negative<Look>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<lookahead_negative<Look>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookahead negative end (sequence)
     template <auto V, typename... Look, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<ctre::sequence<Look...>, look_start<lookahead_negative<>>, Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<lookahead_negative<Look...>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<lookahead_negative<Look...>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // LOOKBEHIND
@@ -4473,10 +3900,8 @@ namespace ctre {
     template <auto V, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::start_lookbehind_positive, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<look_start<lookbehind_positive<>>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<look_start<lookbehind_positive<>>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookbehind positive end
@@ -4484,11 +3909,10 @@ namespace ctre {
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<Look, look_start<lookbehind_positive<>>, Ts...>, pcre_parameters<Counter>>) {
       return pcre_context {
-          ctll::list<
-              lookbehind_positive<
-                  decltype(ctre::rotate_for_lookbehind::rotate(Look {}))>,
-              Ts...>(),
-          pcre_parameters<Counter>()
+        ctll::
+          list<lookbehind_positive<decltype(ctre::rotate_for_lookbehind::rotate(Look {}))>, Ts...>(
+          ),
+        pcre_parameters<Counter>()
       };
     }
 
@@ -4496,26 +3920,18 @@ namespace ctre {
     template <auto V, typename... Look, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<ctre::sequence<Look...>, look_start<lookbehind_positive<>>, Ts...>, pcre_parameters<Counter>>) {
-      using my_lookbehind =
-          decltype(ctre::convert_to_basic_list<lookbehind_positive>(
-              ctll::rotate(
-                  ctll::list<decltype(ctre::rotate_for_lookbehind::rotate(Look {
-                  }))...> {}
-              )
-          ));
-      return pcre_context {
-          ctll::list<my_lookbehind, Ts...>(), pcre_parameters<Counter>()
-      };
+      using my_lookbehind = decltype(ctre::convert_to_basic_list<lookbehind_positive>(
+        ctll::rotate(ctll::list<decltype(ctre::rotate_for_lookbehind::rotate(Look {}))...> {})
+      ));
+      return pcre_context { ctll::list<my_lookbehind, Ts...>(), pcre_parameters<Counter>() };
     }
 
     // lookbehind negative start
     template <auto V, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::start_lookbehind_negative, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
-      return pcre_context {
-          ctll::list<look_start<lookbehind_negative<>>, Ts...>(),
-          pcre_parameters<Counter>()
-      };
+      return pcre_context { ctll::list<look_start<lookbehind_negative<>>, Ts...>(),
+                            pcre_parameters<Counter>() };
     }
 
     // lookbehind negative end
@@ -4523,11 +3939,10 @@ namespace ctre {
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<Look, look_start<lookbehind_negative<>>, Ts...>, pcre_parameters<Counter>>) {
       return pcre_context {
-          ctll::list<
-              lookbehind_negative<
-                  decltype(ctre::rotate_for_lookbehind::rotate(Look {}))>,
-              Ts...>(),
-          pcre_parameters<Counter>()
+        ctll::
+          list<lookbehind_negative<decltype(ctre::rotate_for_lookbehind::rotate(Look {}))>, Ts...>(
+          ),
+        pcre_parameters<Counter>()
       };
     }
 
@@ -4535,16 +3950,10 @@ namespace ctre {
     template <auto V, typename... Look, typename... Ts, size_t Counter>
     static constexpr auto
     apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<ctre::sequence<Look...>, look_start<lookbehind_negative<>>, Ts...>, pcre_parameters<Counter>>) {
-      using my_lookbehind =
-          decltype(ctre::convert_to_basic_list<lookbehind_negative>(
-              ctll::rotate(
-                  ctll::list<decltype(ctre::rotate_for_lookbehind::rotate(Look {
-                  }))...> {}
-              )
-          ));
-      return pcre_context {
-          ctll::list<my_lookbehind, Ts...>(), pcre_parameters<Counter>()
-      };
+      using my_lookbehind = decltype(ctre::convert_to_basic_list<lookbehind_negative>(
+        ctll::rotate(ctll::list<decltype(ctre::rotate_for_lookbehind::rotate(Look {}))...> {})
+      ));
+      return pcre_context { ctll::list<my_lookbehind, Ts...>(), pcre_parameters<Counter>() };
     }
 
 #endif
@@ -4555,170 +3964,142 @@ namespace ctre {
     // class_named_alnum
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_alnum,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_alnum,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::alphanum_chars(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::alphanum_chars(), subject.stack),
+                            subject.parameters };
     }
     // class_named_alpha
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_alpha,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_alpha,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::alpha_chars(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::alpha_chars(), subject.stack),
+                            subject.parameters };
     }
     // class_named_digit
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_digit,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_digit,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::digit_chars(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::digit_chars(), subject.stack),
+                            subject.parameters };
     }
     // class_named_ascii
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_ascii,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_ascii,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::ascii_chars(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::ascii_chars(), subject.stack),
+                            subject.parameters };
     }
     // class_named_blank
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_blank,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_blank,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::enumeration<' ', '\t'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::enumeration<' ', '\t'>(), subject.stack),
+                            subject.parameters };
     }
     // class_named_cntrl
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_cntrl,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_cntrl,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              ctre::set<
-                  ctre::char_range<'\x00', '\x1F'>, ctre::character<'\x7F'>>(),
-              subject.stack
-          ),
-          subject.parameters
+        ctll::push_front(
+          ctre::set<ctre::char_range<'\x00', '\x1F'>, ctre::character<'\x7F'>>(), subject.stack
+        ),
+        subject.parameters
       };
     }
     // class_named_graph
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_graph,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_graph,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::char_range<'\x21', '\x7E'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::char_range<'\x21', '\x7E'>(), subject.stack),
+                            subject.parameters };
     }
     // class_named_lower
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_lower,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_lower,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::char_range<'a', 'z'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::char_range<'a', 'z'>(), subject.stack),
+                            subject.parameters };
     }
     // class_named_upper
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_upper,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_upper,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::char_range<'A', 'Z'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::char_range<'A', 'Z'>(), subject.stack),
+                            subject.parameters };
     }
     // class_named_print
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_print,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_print,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(ctre::char_range<'\x20', '\x7E'>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(ctre::char_range<'\x20', '\x7E'>(), subject.stack),
+                            subject.parameters };
     }
     // class_named_space
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_space,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_space,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(space_chars(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(space_chars(), subject.stack), subject.parameters };
     }
     // class_named_word
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_word,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_word,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(word_chars(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(word_chars(), subject.stack), subject.parameters };
     }
     // class_named_punct
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_punct,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_punct,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(punct_chars(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(punct_chars(), subject.stack), subject.parameters };
     }
     // class_named_xdigit
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::class_named_xdigit,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::class_named_xdigit,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(xdigit_chars(), subject.stack), subject.parameters
-      };
+      return pcre_context { ctll::push_front(xdigit_chars(), subject.stack), subject.parameters };
     }
 
 #endif
@@ -4728,142 +4109,102 @@ namespace ctre {
 
     // empty option for alternate
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::push_empty,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(empty(), subject.stack), subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::push_empty, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(empty(), subject.stack), subject.parameters };
     }
 
     // empty option for empty regex
     template <typename Parameters>
-    static constexpr auto apply(
-        pcre::push_empty,
-        ctll::epsilon,
-        pcre_context<ctll::list<>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(empty(), subject.stack), subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::push_empty, ctll::epsilon, pcre_context<ctll::list<>, Parameters> subject) {
+      return pcre_context { ctll::push_front(empty(), subject.stack), subject.parameters };
     }
 
     // make_alternate (A|B)
-    template <
-        auto V,
-        typename A,
-        typename B,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename A, typename B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_alternate,
-        ctll::term<V>,
-        pcre_context<ctll::list<B, A, Ts...>, Parameters> subject
+      pcre::make_alternate,
+      ctll::term<V>,
+      pcre_context<ctll::list<B, A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(select<A, B>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(select<A, B>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // make_alternate (As..)|B => (As..|B)
-    template <
-        auto V,
-        typename A,
-        typename... Bs,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename A, typename... Bs, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_alternate,
-        ctll::term<V>,
-        pcre_context<ctll::list<ctre::select<Bs...>, A, Ts...>, Parameters>
-            subject
+      pcre::make_alternate,
+      ctll::term<V>,
+      pcre_context<ctll::list<ctre::select<Bs...>, A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(select<A, Bs...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(select<A, Bs...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_optional
     template <auto V, typename A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_optional,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, Ts...>, Parameters> subject
+      pcre::make_optional,
+      ctll::term<V>,
+      pcre_context<ctll::list<A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(optional<A>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(optional<A>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     template <auto V, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_optional,
-        ctll::term<V>,
-        pcre_context<ctll::list<sequence<Content...>, Ts...>, Parameters>
-            subject
+      pcre::make_optional,
+      ctll::term<V>,
+      pcre_context<ctll::list<sequence<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(optional<Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(optional<Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // prevent from creating wrapped optionals
     template <auto V, typename A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_optional,
-        ctll::term<V>,
-        pcre_context<ctll::list<optional<A>, Ts...>, Parameters> subject
+      pcre::make_optional,
+      ctll::term<V>,
+      pcre_context<ctll::list<optional<A>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(optional<A>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(optional<A>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // in case inner optional is lazy, result should be lazy too
     template <auto V, typename A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_optional,
-        ctll::term<V>,
-        pcre_context<ctll::list<lazy_optional<A>, Ts...>, Parameters> subject
+      pcre::make_optional,
+      ctll::term<V>,
+      pcre_context<ctll::list<lazy_optional<A>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(lazy_optional<A>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(lazy_optional<A>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_lazy (optional)
     template <auto V, typename... Subject, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_lazy,
-        ctll::term<V>,
-        pcre_context<ctll::list<optional<Subject...>, Ts...>, Parameters>
-            subject
+      pcre::make_lazy,
+      ctll::term<V>,
+      pcre_context<ctll::list<optional<Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(lazy_optional<Subject...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(lazy_optional<Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // if you already got a lazy optional, make_lazy is no-op
     template <auto V, typename... Subject, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_lazy,
-        ctll::term<V>,
-        pcre_context<ctll::list<lazy_optional<Subject...>, Ts...>, Parameters>
-            subject
+      pcre::make_lazy,
+      ctll::term<V>,
+      pcre_context<ctll::list<lazy_optional<Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(lazy_optional<Subject...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(lazy_optional<Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
 #endif
@@ -4874,92 +4215,112 @@ namespace ctre {
     // push_property_name
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_property_name,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_property_name,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(property_name<V>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(property_name<V>(), subject.stack),
+                            subject.parameters };
     }
     // push_property_name (concat)
     template <auto... Str, auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_property_name,
-        ctll::term<V>,
-        pcre_context<ctll::list<property_name<Str...>, Ts...>, Parameters>
-            subject
+      pcre::push_property_name,
+      ctll::term<V>,
+      pcre_context<ctll::list<property_name<Str...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(property_name<Str..., V>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(property_name<Str..., V>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // push_property_value
     template <auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_property_value,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
+      pcre::push_property_value,
+      ctll::term<V>,
+      pcre_context<ctll::list<Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(property_value<V>(), subject.stack),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(property_value<V>(), subject.stack),
+                            subject.parameters };
     }
     // push_property_value (concat)
     template <auto... Str, auto V, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_property_value,
-        ctll::term<V>,
-        pcre_context<ctll::list<property_value<Str...>, Ts...>, Parameters>
-            subject
+      pcre::push_property_value,
+      ctll::term<V>,
+      pcre_context<ctll::list<property_value<Str...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(property_value<Str..., V>(), ctll::list<Ts...>()),
+      return pcre_context { ctll::push_front(property_value<Str..., V>(), ctll::list<Ts...>()),
+                            subject.parameters };
+    }
+
+    // make_property
+    template <auto V, auto... Name, typename... Ts, typename Parameters>
+    static constexpr auto apply(
+      pcre::make_property,
+      ctll::term<V>,
+      [[maybe_unused]] pcre_context<ctll::list<property_name<Name...>, Ts...>, Parameters> subject
+    ) {
+      // return ctll::reject{};
+      constexpr char name[sizeof...(Name)] { static_cast<char>(Name)... };
+      constexpr auto p = uni::detail::binary_prop_from_string(get_string_view(name));
+
+      if constexpr (uni::detail::is_unknown(p)) {
+        return ctll::reject {};
+      } else {
+        return pcre_context { ctll::push_front(make_binary_property<p>(), ctll::list<Ts...>()),
+                              subject.parameters };
+      }
+    }
+
+    // make_property
+    template <auto V, auto... Value, auto... Name, typename... Ts, typename Parameters>
+    static constexpr auto apply(
+      pcre::make_property,
+      ctll::term<V>,
+      [[maybe_unused]] pcre_context<
+        ctll::list<property_value<Value...>, property_name<Name...>, Ts...>,
+        Parameters> subject
+    ) {
+      // return ctll::reject{};
+      constexpr auto prop = property_builder<Name...>::template get<Value...>();
+
+      if constexpr (std::is_same_v<decltype(prop), ctll::reject>) {
+        return ctll::reject {};
+      } else {
+        return pcre_context { ctll::push_front(prop, ctll::list<Ts...>()), subject.parameters };
+      }
+    }
+
+    // make_property_negative
+    template <auto V, auto... Name, typename... Ts, typename Parameters>
+    static constexpr auto apply(
+      pcre::make_property_negative,
+      ctll::term<V>,
+      [[maybe_unused]] pcre_context<ctll::list<property_name<Name...>, Ts...>, Parameters> subject
+    ) {
+      // return ctll::reject{};
+      constexpr char name[sizeof...(Name)] { static_cast<char>(Name)... };
+      constexpr auto p = uni::detail::binary_prop_from_string(get_string_view(name));
+
+      if constexpr (uni::detail::is_unknown(p)) {
+        return ctll::reject {};
+      } else {
+        return pcre_context {
+          ctll::push_front(negate<make_binary_property<p>>(), ctll::list<Ts...>()),
           subject.parameters
-      };
-    }
-
-    // make_property
-    template <auto V, auto... Name, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::make_property,
-        ctll::term<V>,
-        [[maybe_unused]] pcre_context<
-            ctll::list<property_name<Name...>, Ts...>,
-            Parameters> subject
-    ) {
-      // return ctll::reject{};
-      constexpr char name[sizeof...(Name)] {static_cast<char>(Name)...};
-      constexpr auto p =
-          uni::detail::binary_prop_from_string(get_string_view(name));
-
-      if constexpr (uni::detail::is_unknown(p)) {
-        return ctll::reject {};
-      } else {
-        return pcre_context {
-            ctll::push_front(make_binary_property<p>(), ctll::list<Ts...>()),
-            subject.parameters
         };
       }
     }
 
-    // make_property
-    template <
-        auto V,
-        auto... Value,
-        auto... Name,
-        typename... Ts,
-        typename Parameters>
+    // make_property_negative
+    template <auto V, auto... Value, auto... Name, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_property,
-        ctll::term<V>,
-        [[maybe_unused]] pcre_context<
-            ctll::list<property_value<Value...>, property_name<Name...>, Ts...>,
-            Parameters> subject
+      pcre::make_property_negative,
+      ctll::term<V>,
+      [[maybe_unused]] pcre_context<
+        ctll::list<property_value<Value...>, property_name<Name...>, Ts...>,
+        Parameters> subject
     ) {
       // return ctll::reject{};
       constexpr auto prop = property_builder<Name...>::template get<Value...>();
@@ -4967,62 +4328,8 @@ namespace ctre {
       if constexpr (std::is_same_v<decltype(prop), ctll::reject>) {
         return ctll::reject {};
       } else {
-        return pcre_context {
-            ctll::push_front(prop, ctll::list<Ts...>()), subject.parameters
-        };
-      }
-    }
-
-    // make_property_negative
-    template <auto V, auto... Name, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::make_property_negative,
-        ctll::term<V>,
-        [[maybe_unused]] pcre_context<
-            ctll::list<property_name<Name...>, Ts...>,
-            Parameters> subject
-    ) {
-      // return ctll::reject{};
-      constexpr char name[sizeof...(Name)] {static_cast<char>(Name)...};
-      constexpr auto p =
-          uni::detail::binary_prop_from_string(get_string_view(name));
-
-      if constexpr (uni::detail::is_unknown(p)) {
-        return ctll::reject {};
-      } else {
-        return pcre_context {
-            ctll::push_front(
-                negate<make_binary_property<p>>(), ctll::list<Ts...>()
-            ),
-            subject.parameters
-        };
-      }
-    }
-
-    // make_property_negative
-    template <
-        auto V,
-        auto... Value,
-        auto... Name,
-        typename... Ts,
-        typename Parameters>
-    static constexpr auto apply(
-        pcre::make_property_negative,
-        ctll::term<V>,
-        [[maybe_unused]] pcre_context<
-            ctll::list<property_value<Value...>, property_name<Name...>, Ts...>,
-            Parameters> subject
-    ) {
-      // return ctll::reject{};
-      constexpr auto prop = property_builder<Name...>::template get<Value...>();
-
-      if constexpr (std::is_same_v<decltype(prop), ctll::reject>) {
-        return ctll::reject {};
-      } else {
-        return pcre_context {
-            ctll::push_front(negate<decltype(prop)>(), ctll::list<Ts...>()),
-            subject.parameters
-        };
+        return pcre_context { ctll::push_front(negate<decltype(prop)>(), ctll::list<Ts...>()),
+                              subject.parameters };
       }
     }
 
@@ -5034,291 +4341,191 @@ namespace ctre {
     // repeat 1..N
     template <auto V, typename A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_plus,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, Ts...>, Parameters> subject
+      pcre::repeat_plus,
+      ctll::term<V>,
+      pcre_context<ctll::list<A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(plus<A>(), ctll::list<Ts...>()), subject.parameters
-      };
+      return pcre_context { ctll::push_front(plus<A>(), ctll::list<Ts...>()), subject.parameters };
     }
     // repeat 1..N (sequence)
     template <auto V, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_plus,
-        ctll::term<V>,
-        pcre_context<ctll::list<sequence<Content...>, Ts...>, Parameters>
-            subject
+      pcre::repeat_plus,
+      ctll::term<V>,
+      pcre_context<ctll::list<sequence<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(plus<Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(plus<Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // repeat 0..N
     template <auto V, typename A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_star,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, Ts...>, Parameters> subject
+      pcre::repeat_star,
+      ctll::term<V>,
+      pcre_context<ctll::list<A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(star<A>(), ctll::list<Ts...>()), subject.parameters
-      };
+      return pcre_context { ctll::push_front(star<A>(), ctll::list<Ts...>()), subject.parameters };
     }
     // repeat 0..N (sequence)
     template <auto V, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_star,
-        ctll::term<V>,
-        pcre_context<ctll::list<sequence<Content...>, Ts...>, Parameters>
-            subject
+      pcre::repeat_star,
+      ctll::term<V>,
+      pcre_context<ctll::list<sequence<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(star<Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(star<Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // create_number (seed)
     template <auto V, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::create_number,
-        ctll::term<V>,
-        pcre_context<ctll::list<Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(
-              number<static_cast<size_t>(V - '0')>(), subject.stack
-          ),
-          subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::create_number, ctll::term<V>, pcre_context<ctll::list<Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(number<static_cast<size_t>(V - '0')>(), subject.stack),
+                            subject.parameters };
     }
     // push_number
     template <auto V, size_t N, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::push_number,
-        ctll::term<V>,
-        pcre_context<ctll::list<number<N>, Ts...>, Parameters> subject
+      pcre::push_number,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<N>, Ts...>, Parameters> subject
     ) {
       constexpr size_t previous = N * 10ull;
-      return pcre_context {
-          ctll::push_front(
-              number<(previous + (V - '0'))>(), ctll::list<Ts...>()
-          ),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(number<(previous + (V - '0'))>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // repeat A..B
-    template <
-        auto V,
-        typename Subject,
-        size_t A,
-        size_t B,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename Subject, size_t A, size_t B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_ab,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<number<B>, number<A>, Subject, Ts...>,
-            Parameters> subject
+      pcre::repeat_ab,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<B>, number<A>, Subject, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(repeat<A, B, Subject>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(repeat<A, B, Subject>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // repeat A..B (sequence)
-    template <
-        auto V,
-        typename... Content,
-        size_t A,
-        size_t B,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename... Content, size_t A, size_t B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_ab,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<number<B>, number<A>, sequence<Content...>, Ts...>,
-            Parameters> subject
+      pcre::repeat_ab,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<B>, number<A>, sequence<Content...>, Ts...>, Parameters>
+        subject
     ) {
-      return pcre_context {
-          ctll::push_front(repeat<A, B, Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(repeat<A, B, Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // repeat_exactly
-    template <
-        auto V,
-        typename Subject,
-        size_t A,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename Subject, size_t A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_exactly,
-        ctll::term<V>,
-        pcre_context<ctll::list<number<A>, Subject, Ts...>, Parameters> subject
+      pcre::repeat_exactly,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<A>, Subject, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(repeat<A, A, Subject>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(repeat<A, A, Subject>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // repeat_exactly A..B (sequence)
-    template <
-        auto V,
-        typename... Content,
-        size_t A,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename... Content, size_t A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_exactly,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<number<A>, sequence<Content...>, Ts...>,
-            Parameters> subject
+      pcre::repeat_exactly,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<A>, sequence<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(repeat<A, A, Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(repeat<A, A, Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // repeat_at_least (A+)
-    template <
-        auto V,
-        typename Subject,
-        size_t A,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename Subject, size_t A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_at_least,
-        ctll::term<V>,
-        pcre_context<ctll::list<number<A>, Subject, Ts...>, Parameters> subject
+      pcre::repeat_at_least,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<A>, Subject, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(repeat<A, 0, Subject>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(repeat<A, 0, Subject>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // repeat_at_least (A+) (sequence)
-    template <
-        auto V,
-        typename... Content,
-        size_t A,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename... Content, size_t A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::repeat_at_least,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<number<A>, sequence<Content...>, Ts...>,
-            Parameters> subject
+      pcre::repeat_at_least,
+      ctll::term<V>,
+      pcre_context<ctll::list<number<A>, sequence<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(repeat<A, 0, Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(repeat<A, 0, Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_lazy (plus)
     template <auto V, typename... Subject, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_lazy,
-        ctll::term<V>,
-        pcre_context<ctll::list<plus<Subject...>, Ts...>, Parameters> subject
+      pcre::make_lazy,
+      ctll::term<V>,
+      pcre_context<ctll::list<plus<Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(lazy_plus<Subject...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(lazy_plus<Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_lazy (star)
     template <auto V, typename... Subject, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_lazy,
-        ctll::term<V>,
-        pcre_context<ctll::list<star<Subject...>, Ts...>, Parameters> subject
+      pcre::make_lazy,
+      ctll::term<V>,
+      pcre_context<ctll::list<star<Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(lazy_star<Subject...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(lazy_star<Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_lazy (repeat<A,B>)
-    template <
-        auto V,
-        typename... Subject,
-        size_t A,
-        size_t B,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename... Subject, size_t A, size_t B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_lazy,
-        ctll::term<V>,
-        pcre_context<ctll::list<repeat<A, B, Subject...>, Ts...>, Parameters>
-            subject
+      pcre::make_lazy,
+      ctll::term<V>,
+      pcre_context<ctll::list<repeat<A, B, Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(
-              lazy_repeat<A, B, Subject...>(), ctll::list<Ts...>()
-          ),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(lazy_repeat<A, B, Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_possessive (plus)
     template <auto V, typename... Subject, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_possessive,
-        ctll::term<V>,
-        pcre_context<ctll::list<plus<Subject...>, Ts...>, Parameters> subject
+      pcre::make_possessive,
+      ctll::term<V>,
+      pcre_context<ctll::list<plus<Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(possessive_plus<Subject...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(possessive_plus<Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_possessive (star)
     template <auto V, typename... Subject, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_possessive,
-        ctll::term<V>,
-        pcre_context<ctll::list<star<Subject...>, Ts...>, Parameters> subject
+      pcre::make_possessive,
+      ctll::term<V>,
+      pcre_context<ctll::list<star<Subject...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(possessive_star<Subject...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(possessive_star<Subject...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_possessive (repeat<A,B>)
-    template <
-        auto V,
-        typename... Subject,
-        size_t A,
-        size_t B,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename... Subject, size_t A, size_t B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_possessive,
-        ctll::term<V>,
-        pcre_context<ctll::list<repeat<A, B, Subject...>, Ts...>, Parameters>
-            subject
+      pcre::make_possessive,
+      ctll::term<V>,
+      pcre_context<ctll::list<repeat<A, B, Subject...>, Ts...>, Parameters> subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              possessive_repeat<A, B, Subject...>(), ctll::list<Ts...>()
-          ),
-          subject.parameters
+        ctll::push_front(possessive_repeat<A, B, Subject...>(), ctll::list<Ts...>()),
+        subject.parameters
       };
     }
 
@@ -5328,109 +4535,69 @@ namespace ctre {
 #define CTRE__ACTIONS__SEQUENCE__HPP
 
     // make_sequence
-    template <
-        auto V,
-        typename A,
-        typename B,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename A, typename B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<ctll::list<B, A, Ts...>, Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<ctll::list<B, A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(sequence<A, B>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(sequence<A, B>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // make_sequence (concat)
-    template <
-        auto V,
-        typename A,
-        typename... Bs,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename A, typename... Bs, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<ctll::list<sequence<Bs...>, A, Ts...>, Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<ctll::list<sequence<Bs...>, A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(sequence<A, Bs...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(sequence<A, Bs...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_sequence (make string)
     template <auto V, auto A, auto B, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<ctll::list<character<B>, character<A>, Ts...>, Parameters>
-            subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<ctll::list<character<B>, character<A>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(string<A, B>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(string<A, B>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // make_sequence (concat string)
     template <auto V, auto A, auto... Bs, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<ctll::list<string<Bs...>, character<A>, Ts...>, Parameters>
-            subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<ctll::list<string<Bs...>, character<A>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(string<A, Bs...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(string<A, Bs...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // make_sequence (make string in front of different items)
-    template <
-        auto V,
-        auto A,
-        auto B,
-        typename... Sq,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, auto A, auto B, typename... Sq, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<sequence<character<B>, Sq...>, character<A>, Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<ctll::list<sequence<character<B>, Sq...>, character<A>, Ts...>, Parameters>
+        subject
     ) {
-      return pcre_context {
-          ctll::push_front(
-              sequence<string<A, B>, Sq...>(), ctll::list<Ts...>()
-          ),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(sequence<string<A, B>, Sq...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // make_sequence (concat string in front of different items)
-    template <
-        auto V,
-        auto A,
-        auto... Bs,
-        typename... Sq,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, auto A, auto... Bs, typename... Sq, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_sequence,
-        ctll::term<V>,
-        pcre_context<
-            ctll::list<sequence<string<Bs...>, Sq...>, character<A>, Ts...>,
-            Parameters> subject
+      pcre::make_sequence,
+      ctll::term<V>,
+      pcre_context<ctll::list<sequence<string<Bs...>, Sq...>, character<A>, Ts...>, Parameters>
+        subject
     ) {
       return pcre_context {
-          ctll::push_front(
-              sequence<string<A, Bs...>, Sq...>(), ctll::list<Ts...>()
-          ),
-          subject.parameters
+        ctll::push_front(sequence<string<A, Bs...>, Sq...>(), ctll::list<Ts...>()),
+        subject.parameters
       };
     }
 
@@ -5442,13 +4609,13 @@ namespace ctre {
     // UTILITY
     // add into set if not exists
     template <
-        template <typename...>
-        typename SetType,
-        typename T,
-        typename... As,
-        bool Exists = (std::is_same_v<T, As> || ... || false)>
+      template <typename...>
+      typename SetType,
+      typename T,
+      typename... As,
+      bool Exists = (std::is_same_v<T, As> || ... || false)>
     static constexpr auto push_back_into_set(T, SetType<As...>)
-        -> ctll::conditional<Exists, SetType<As...>, SetType<As..., T>> {
+      -> ctll::conditional<Exists, SetType<As...>, SetType<As..., T>> {
       return {};
     }
 
@@ -5473,55 +4640,39 @@ namespace ctre {
 
     // set_start
     template <auto V, typename A, typename... Ts, typename Parameters>
-    static constexpr auto apply(
-        pcre::set_start,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, Ts...>, Parameters> subject
-    ) {
-      return pcre_context {
-          ctll::push_front(set<A>(), ctll::list<Ts...>()), subject.parameters
-      };
+    static constexpr auto
+    apply(pcre::set_start, ctll::term<V>, pcre_context<ctll::list<A, Ts...>, Parameters> subject) {
+      return pcre_context { ctll::push_front(set<A>(), ctll::list<Ts...>()), subject.parameters };
     }
     // set_make
     template <auto V, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::set_make,
-        ctll::term<V>,
-        pcre_context<ctll::list<set<Content...>, Ts...>, Parameters> subject
+      pcre::set_make,
+      ctll::term<V>,
+      pcre_context<ctll::list<set<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(set<Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(set<Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // set_make_negative
     template <auto V, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::set_make_negative,
-        ctll::term<V>,
-        pcre_context<ctll::list<set<Content...>, Ts...>, Parameters> subject
+      pcre::set_make_negative,
+      ctll::term<V>,
+      pcre_context<ctll::list<set<Content...>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(negative_set<Content...>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(negative_set<Content...>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
     // set{A...} + B = set{A,B}
-    template <
-        auto V,
-        typename A,
-        typename... Content,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename A, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::set_combine,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, set<Content...>, Ts...>, Parameters> subject
+      pcre::set_combine,
+      ctll::term<V>,
+      pcre_context<ctll::list<A, set<Content...>, Ts...>, Parameters> subject
     ) {
       auto new_set = push_back_into_set<set>(A(), set<Content...>());
-      return pcre_context {
-          ctll::push_front(new_set, ctll::list<Ts...>()), subject.parameters
-      };
+      return pcre_context { ctll::push_front(new_set, ctll::list<Ts...>()), subject.parameters };
     }
     // TODO checkme
     //// set{A...} + set{B...} = set{A...,B...}
@@ -5535,22 +4686,14 @@ namespace ctre {
     // }
 
     // negative_set{A...} + B = negative_set{A,B}
-    template <
-        auto V,
-        typename A,
-        typename... Content,
-        typename... Ts,
-        typename Parameters>
+    template <auto V, typename A, typename... Content, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::set_combine,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, negative_set<Content...>, Ts...>, Parameters>
-            subject
+      pcre::set_combine,
+      ctll::term<V>,
+      pcre_context<ctll::list<A, negative_set<Content...>, Ts...>, Parameters> subject
     ) {
       auto new_set = push_back_into_set<set>(A(), set<Content...>());
-      return pcre_context {
-          ctll::push_front(new_set, ctll::list<Ts...>()), subject.parameters
-      };
+      return pcre_context { ctll::push_front(new_set, ctll::list<Ts...>()), subject.parameters };
     }
     // TODO checkme
     //// negative_set{A...} + negative_set{B...} = negative_set{A...,B...}
@@ -5566,27 +4709,23 @@ namespace ctre {
     //  negate_class_named: [[^:digit:]] = [^[:digit:]]
     template <auto V, typename A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::negate_class_named,
-        ctll::term<V>,
-        pcre_context<ctll::list<A, Ts...>, Parameters> subject
+      pcre::negate_class_named,
+      ctll::term<V>,
+      pcre_context<ctll::list<A, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(negate<A>(), ctll::list<Ts...>()), subject.parameters
-      };
+      return pcre_context { ctll::push_front(negate<A>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
     // add range to set
     template <auto V, auto B, auto A, typename... Ts, typename Parameters>
     static constexpr auto apply(
-        pcre::make_range,
-        ctll::term<V>,
-        pcre_context<ctll::list<character<B>, character<A>, Ts...>, Parameters>
-            subject
+      pcre::make_range,
+      ctll::term<V>,
+      pcre_context<ctll::list<character<B>, character<A>, Ts...>, Parameters> subject
     ) {
-      return pcre_context {
-          ctll::push_front(char_range<A, B>(), ctll::list<Ts...>()),
-          subject.parameters
-      };
+      return pcre_context { ctll::push_front(char_range<A, B>(), ctll::list<Ts...>()),
+                            subject.parameters };
     }
 
 #endif
@@ -5603,9 +4742,7 @@ namespace ctre {
     template <typename Mode, typename... Ts, size_t Id, size_t Counter>
     static constexpr auto
     apply_mode(Mode, ctll::list<capture_id<Id>, Ts...>, pcre_parameters<Counter>) {
-      return pcre_context<
-          ctll::list<mode_switch<Mode>, Ts...>, pcre_parameters<Counter - 1>> {
-      };
+      return pcre_context<ctll::list<mode_switch<Mode>, Ts...>, pcre_parameters<Counter - 1>> {};
     }
 
     // catch a semantic action into mode
@@ -5651,8 +4788,7 @@ namespace ctre {
 namespace ctre {
 
   template <typename... Content>
-  constexpr bool
-  starts_with_anchor(const flags&, ctll::list<Content...>) noexcept {
+  constexpr bool starts_with_anchor(const flags&, ctll::list<Content...>) noexcept {
     return false;
   }
 
@@ -5667,8 +4803,7 @@ namespace ctre {
   constexpr bool
   starts_with_anchor(const flags& f, ctll::list<assert_line_begin, Content...>) noexcept {
     // yes! start line anchor is here
-    return !ctre::multiline_mode(f) ||
-           starts_with_anchor(f, ctll::list<Content...> {});
+    return !ctre::multiline_mode(f) || starts_with_anchor(f, ctll::list<Content...> {});
   }
 
   template <typename CharLike, typename... Content>
@@ -5684,9 +4819,7 @@ namespace ctre {
   starts_with_anchor(const flags& f, ctll::list<select<Options...>, Content...>) noexcept {
     // check if all options starts with anchor or if they are empty, there is an
     // anchor behind them
-    return (
-        starts_with_anchor(f, ctll::list<Options, Content...> {}) && ... && true
-    );
+    return (starts_with_anchor(f, ctll::list<Options, Content...> {}) && ... && true);
   }
 
   template <typename... Optional, typename... Content>
@@ -5801,43 +4934,37 @@ namespace ctre {
       friend auto operator==(self_type, self_type) noexcept -> bool;
       auto        operator*() noexcept -> reference;
 
-      friend constexpr auto
-      operator==(self_type, const char8_t* other_ptr) noexcept {
-        return *other_ptr == char8_t {0};
+      friend constexpr auto operator==(self_type, const char8_t* other_ptr) noexcept {
+        return *other_ptr == char8_t { 0 };
       }
 
-      friend constexpr auto
-      operator!=(self_type, const char8_t* other_ptr) noexcept {
-        return *other_ptr != char8_t {0};
+      friend constexpr auto operator!=(self_type, const char8_t* other_ptr) noexcept {
+        return *other_ptr != char8_t { 0 };
       }
 
 #if __cpp_impl_three_way_comparison < 201907L
-      friend constexpr auto
-      operator==(const char8_t* other_ptr, self_type) noexcept {
-        return *other_ptr == char8_t {0};
+      friend constexpr auto operator==(const char8_t* other_ptr, self_type) noexcept {
+        return *other_ptr == char8_t { 0 };
       }
 
-      friend constexpr auto
-      operator!=(const char8_t* other_ptr, self_type) noexcept {
-        return *other_ptr != char8_t {0};
+      friend constexpr auto operator!=(const char8_t* other_ptr, self_type) noexcept {
+        return *other_ptr != char8_t { 0 };
       }
 #endif
     };
 
-    const char8_t* ptr {nullptr};
-    const char8_t* end {nullptr};
+    const char8_t* ptr { nullptr };
+    const char8_t* end { nullptr };
 
     constexpr friend bool operator!=(const utf8_iterator& lhs, sentinel) {
       return lhs.ptr < lhs.end;
     }
 
-    constexpr friend bool
-    operator!=(const utf8_iterator& lhs, const char8_t* rhs) {
+    constexpr friend bool operator!=(const utf8_iterator& lhs, const char8_t* rhs) {
       return lhs.ptr != rhs;
     }
 
-    constexpr friend bool
-    operator!=(const utf8_iterator& lhs, const utf8_iterator& rhs) {
+    constexpr friend bool operator!=(const utf8_iterator& lhs, const utf8_iterator& rhs) {
       return lhs.ptr != rhs.ptr;
     }
 
@@ -5845,13 +4972,11 @@ namespace ctre {
       return lhs.ptr >= lhs.end;
     }
 
-    constexpr friend bool
-    operator==(const utf8_iterator& lhs, const char8_t* rhs) {
+    constexpr friend bool operator==(const utf8_iterator& lhs, const char8_t* rhs) {
       return lhs.ptr == rhs;
     }
 
-    constexpr friend bool
-    operator==(const utf8_iterator& lhs, const utf8_iterator& rhs) {
+    constexpr friend bool operator==(const utf8_iterator& lhs, const utf8_iterator& rhs) {
       return lhs.ptr == rhs.ptr;
     }
 
@@ -5860,8 +4985,7 @@ namespace ctre {
       return rhs.ptr < rhs.end;
     }
 
-    constexpr friend bool
-    operator!=(const char8_t* lhs, const utf8_iterator& rhs) {
+    constexpr friend bool operator!=(const char8_t* lhs, const utf8_iterator& rhs) {
       return lhs == rhs.ptr;
     }
 
@@ -5869,8 +4993,7 @@ namespace ctre {
       return rhs.ptr >= rhs.end;
     }
 
-    constexpr friend bool
-    operator==(const char8_t* lhs, const utf8_iterator& rhs) {
+    constexpr friend bool operator==(const char8_t* lhs, const utf8_iterator& rhs) {
       return lhs == rhs.ptr;
     }
 #endif
@@ -5940,29 +5063,24 @@ namespace ctre {
       constexpr char32_t mojibake = 0xFFFDull;
 
       // quickpath
-      if (!(*ptr & 0b1000'0000u)) CTRE_LIKELY {
-          return *ptr;
-        }
+      if (!(*ptr & 0b1000'0000u))
+        CTRE_LIKELY { return *ptr; }
 
       // calculate length based on first 5 bits
-      const unsigned length =
-          ((0x3A55000000000000ull >> ((*ptr >> 2) & 0b111110u)) & 0b11u);
+      const unsigned length = ((0x3A55000000000000ull >> ((*ptr >> 2) & 0b111110u)) & 0b11u);
 
       // actual length is number + 1 bytes
 
       // length 0 here means it's a bad front unit
-      if (!length) CTRE_UNLIKELY {
-          return mojibake;
-        }
+      if (!length)
+        CTRE_UNLIKELY { return mojibake; }
 
       // if part of the utf-8 sequence is past the end
-      if (((ptr + length) >= end)) CTRE_UNLIKELY {
-          return mojibake;
-        }
+      if (((ptr + length) >= end))
+        CTRE_UNLIKELY { return mojibake; }
 
-      if ((ptr[1] & 0b1100'0000u) != 0b1000'0000) CTRE_UNLIKELY {
-          return mojibake;
-        }
+      if ((ptr[1] & 0b1100'0000u) != 0b1000'0000)
+        CTRE_UNLIKELY { return mojibake; }
 
       const char8_t mask = static_cast<char8_t>(0b0011'1111u >> length);
 
@@ -5973,27 +5091,22 @@ namespace ctre {
       // remove utf8 front bits, get only significant part
       // and add first trailing unit
 
-      char32_t result = static_cast<char32_t>((ptr[0] & mask) << 6u) |
-                        (ptr[1] & 0b0011'1111u);
+      char32_t result = static_cast<char32_t>((ptr[0] & mask) << 6u) | (ptr[1] & 0b0011'1111u);
 
       // add rest of trailing units
-      if (length == 1) CTRE_LIKELY {
-          return result;
-        }
+      if (length == 1)
+        CTRE_LIKELY { return result; }
 
-      if ((ptr[2] & 0b1100'0000u) != 0b1000'0000) CTRE_UNLIKELY {
-          return mojibake;
-        }
+      if ((ptr[2] & 0b1100'0000u) != 0b1000'0000)
+        CTRE_UNLIKELY { return mojibake; }
 
       result = (result << 6) | (ptr[2] & 0b0011'1111u);
 
-      if (length == 2) CTRE_LIKELY {
-          return result;
-        }
+      if (length == 2)
+        CTRE_LIKELY { return result; }
 
-      if ((ptr[3] & 0b1100'0000u) != 0b1000'0000) CTRE_UNLIKELY {
-          return mojibake;
-        }
+      if ((ptr[3] & 0b1100'0000u) != 0b1000'0000)
+        CTRE_UNLIKELY { return mojibake; }
 
       return (result << 6) | (ptr[3] & 0b0011'1111u);
     }
@@ -6002,10 +5115,10 @@ namespace ctre {
 #ifdef CTRE_ENABLE_UTF8_RANGE
   struct utf8_range {
     std::u8string_view range;
-    constexpr utf8_range(std::u8string_view r) noexcept : range {r} {}
+    constexpr utf8_range(std::u8string_view r) noexcept : range { r } {}
 
     constexpr auto begin() const noexcept {
-      return utf8_iterator {range.data(), range.data() + range.size()};
+      return utf8_iterator { range.data(), range.data() + range.size() };
     }
     constexpr auto end() const noexcept { return utf8_iterator::sentinel {}; }
   };
@@ -6032,8 +5145,7 @@ namespace ctre {
 
 namespace ctre {
 
-  constexpr auto
-  is_random_accessible_f(const std::random_access_iterator_tag&) {
+  constexpr auto is_random_accessible_f(const std::random_access_iterator_tag&) {
     return std::true_type {};
   }
   constexpr auto is_random_accessible_f(...) { return std::false_type {}; }
@@ -6046,10 +5158,9 @@ namespace ctre {
 
   template <typename T>
   constexpr bool is_random_accessible =
-      decltype(is_random_accessible_f(std::declval<const T&>())) {};
+    decltype(is_random_accessible_f(std::declval<const T&>())) {};
   template <typename T>
-  constexpr bool is_reverse_iterator =
-      decltype(is_reverse_iterator_f(std::declval<const T&>())) {};
+  constexpr bool is_reverse_iterator = decltype(is_reverse_iterator_f(std::declval<const T&>())) {};
 
   struct not_matched_tag_t {};
 
@@ -6062,7 +5173,7 @@ namespace ctre {
       Iterator _begin {};
       Iterator _end {};
 
-      bool _matched {false};
+      bool _matched { false };
 
      public:
       using char_type = typename std::iterator_traits<Iterator>::value_type;
@@ -6071,32 +5182,23 @@ namespace ctre {
 
       constexpr CTRE_FORCE_INLINE storage() noexcept {}
 
-      constexpr CTRE_FORCE_INLINE void matched() noexcept { _matched = true; }
-      constexpr CTRE_FORCE_INLINE void unmatch() noexcept { _matched = false; }
-      constexpr CTRE_FORCE_INLINE void set_start(Iterator pos) noexcept {
-        _begin = pos;
-      }
+      constexpr CTRE_FORCE_INLINE void     matched() noexcept { _matched = true; }
+      constexpr CTRE_FORCE_INLINE void     unmatch() noexcept { _matched = false; }
+      constexpr CTRE_FORCE_INLINE void     set_start(Iterator pos) noexcept { _begin = pos; }
       constexpr CTRE_FORCE_INLINE storage& set_end(Iterator pos) noexcept {
         _end = pos;
         return *this;
       }
-      constexpr CTRE_FORCE_INLINE Iterator get_end() const noexcept {
-        return _end;
-      }
+      constexpr CTRE_FORCE_INLINE Iterator get_end() const noexcept { return _end; }
 
       constexpr auto begin() const noexcept { return _begin; }
       constexpr auto end() const noexcept { return _end; }
 
-      constexpr explicit CTRE_FORCE_INLINE operator bool() const noexcept {
-        return _matched;
-      }
+      constexpr explicit CTRE_FORCE_INLINE operator bool() const noexcept { return _matched; }
 
       template <typename It = Iterator>
       constexpr CTRE_FORCE_INLINE const auto* data_unsafe() const noexcept {
-        static_assert(
-            !is_reverse_iterator<It>,
-            "Iterator in your capture must not be reverse!"
-        );
+        static_assert(!is_reverse_iterator<It>, "Iterator in your capture must not be reverse!");
 
 #if __cpp_char8_t >= 201811
         if constexpr (std::is_same_v<Iterator, utf8_iterator>) {
@@ -6105,10 +5207,9 @@ namespace ctre {
 #endif
 
 #ifdef _MSC_VER
-          return std::to_address(_begin
-          ); // I'm enabling this only for MSVC for now, as some clang
-             // old versions with various libraries (random
-             // combinations) has different problems
+          return std::to_address(_begin); // I'm enabling this only for MSVC for now, as some clang
+                                          // old versions with various libraries (random
+                                          // combinations) has different problems
 #else
         return &*_begin;
 #endif
@@ -6121,14 +5222,13 @@ namespace ctre {
       template <typename It = Iterator>
       constexpr CTRE_FORCE_INLINE const auto* data() const noexcept {
         constexpr bool must_be_contiguous_nonreverse_iterator =
-            is_random_accessible<
-                typename std::iterator_traits<It>::iterator_category> &&
-            !is_reverse_iterator<It>;
+          is_random_accessible<typename std::iterator_traits<It>::iterator_category> &&
+          !is_reverse_iterator<It>;
 
         static_assert(
-            must_be_contiguous_nonreverse_iterator,
-            "To access result as a pointer you need to provide a random access "
-            "iterator/range to regex (which is not reverse iterator based)."
+          must_be_contiguous_nonreverse_iterator,
+          "To access result as a pointer you need to provide a random access "
+          "iterator/range to regex (which is not reverse iterator based)."
         );
 
         return data_unsafe();
@@ -6152,9 +5252,8 @@ namespace ctre {
 
 #if __has_include(<charconv>)
       template <typename R = int>
-      constexpr CTRE_FORCE_INLINE auto to_number(int base = 10) const noexcept
-          -> R {
-        R          result {0};
+      constexpr CTRE_FORCE_INLINE auto to_number(int base = 10) const noexcept -> R {
+        R          result { 0 };
         const auto view = to_view();
         std::from_chars(view.data(), view.data() + view.size(), result, base);
         return result;
@@ -6168,28 +5267,23 @@ namespace ctre {
       constexpr CTRE_FORCE_INLINE auto to_view() const noexcept {
         // random access, because C++ (waving hands around)
         constexpr bool must_be_nonreverse_contiguous_iterator =
-            is_random_accessible<typename std::iterator_traits<
-                std::remove_const_t<It>>::iterator_category> &&
-            !is_reverse_iterator<It>;
+          is_random_accessible<
+            typename std::iterator_traits<std::remove_const_t<It>>::iterator_category> &&
+          !is_reverse_iterator<It>;
 
         static_assert(
-            must_be_nonreverse_contiguous_iterator,
-            "To convert capture into a basic_string_view you need to provide a "
-            "pointer or a contiguous non-reverse iterator/range to regex."
+          must_be_nonreverse_contiguous_iterator,
+          "To convert capture into a basic_string_view you need to provide a "
+          "pointer or a contiguous non-reverse iterator/range to regex."
         );
 
-        return std::basic_string_view<char_type>(
-            data_unsafe(), static_cast<size_t>(unit_size())
-        );
+        return std::basic_string_view<char_type>(data_unsafe(), static_cast<size_t>(unit_size()));
       }
 
-      constexpr CTRE_FORCE_INLINE std::basic_string<char_type> to_string(
-      ) const noexcept {
+      constexpr CTRE_FORCE_INLINE std::basic_string<char_type> to_string() const noexcept {
 #if __cpp_char8_t >= 201811
         if constexpr (std::is_same_v<Iterator, utf8_iterator>) {
-          return std::basic_string<char_type>(
-              data_unsafe(), static_cast<size_t>(unit_size())
-          );
+          return std::basic_string<char_type>(data_unsafe(), static_cast<size_t>(unit_size()));
         } else {
           return std::basic_string<char_type>(begin(), end());
         }
@@ -6198,52 +5292,37 @@ namespace ctre {
 #endif
       }
 
-      constexpr CTRE_FORCE_INLINE auto view() const noexcept {
+      constexpr CTRE_FORCE_INLINE auto view() const noexcept { return to_view(); }
+
+      constexpr CTRE_FORCE_INLINE auto str() const noexcept { return to_string(); }
+
+      constexpr CTRE_FORCE_INLINE operator std::basic_string_view<char_type>() const noexcept {
         return to_view();
       }
 
-      constexpr CTRE_FORCE_INLINE auto str() const noexcept {
-        return to_string();
-      }
-
-      constexpr CTRE_FORCE_INLINE operator std::basic_string_view<char_type>(
-      ) const noexcept {
-        return to_view();
-      }
-
-      constexpr CTRE_FORCE_INLINE explicit
-      operator std::basic_string<char_type>() const noexcept {
+      constexpr CTRE_FORCE_INLINE explicit operator std::basic_string<char_type>() const noexcept {
         return to_string();
       }
 
       constexpr CTRE_FORCE_INLINE static size_t get_id() noexcept { return Id; }
 
-      friend CTRE_FORCE_INLINE constexpr bool operator==(
-          const storage&                    lhs,
-          std::basic_string_view<char_type> rhs
-      ) noexcept {
+      friend CTRE_FORCE_INLINE constexpr bool
+      operator==(const storage& lhs, std::basic_string_view<char_type> rhs) noexcept {
         return bool(lhs) ? lhs.view() == rhs : false;
       }
-      friend CTRE_FORCE_INLINE constexpr bool operator!=(
-          const storage&                    lhs,
-          std::basic_string_view<char_type> rhs
-      ) noexcept {
+      friend CTRE_FORCE_INLINE constexpr bool
+      operator!=(const storage& lhs, std::basic_string_view<char_type> rhs) noexcept {
         return bool(lhs) ? lhs.view() != rhs : false;
       }
-      friend CTRE_FORCE_INLINE constexpr bool operator==(
-          std::basic_string_view<char_type> lhs,
-          const storage&                    rhs
-      ) noexcept {
+      friend CTRE_FORCE_INLINE constexpr bool
+      operator==(std::basic_string_view<char_type> lhs, const storage& rhs) noexcept {
         return bool(rhs) ? lhs == rhs.view() : false;
       }
-      friend CTRE_FORCE_INLINE constexpr bool operator!=(
-          std::basic_string_view<char_type> lhs,
-          const storage&                    rhs
-      ) noexcept {
+      friend CTRE_FORCE_INLINE constexpr bool
+      operator!=(std::basic_string_view<char_type> lhs, const storage& rhs) noexcept {
         return bool(rhs) ? lhs != rhs.view() : false;
       }
-      friend CTRE_FORCE_INLINE std::ostream&
-      operator<<(std::ostream& str, const storage& rhs) {
+      friend CTRE_FORCE_INLINE std::ostream& operator<<(std::ostream& str, const storage& rhs) {
         return str << rhs.view();
       }
     };
@@ -6332,8 +5411,8 @@ namespace ctre {
     template <const auto& Name>
     CTRE_FORCE_INLINE constexpr auto& select() const noexcept {
 #endif
-        if constexpr (std::is_same_v<typename Head::name, void>) {
-          return captures<Tail...>::template select<Name>();
+      if constexpr (std::is_same_v<typename Head::name, void>) {
+        return captures<Tail...>::template select<Name>();
   } else {
     if constexpr (Head::name::name.is_same_as(Name)) {
       return head;
@@ -6380,7 +5459,7 @@ struct captures<> {
     template <const auto&>
     CTRE_FORCE_INLINE constexpr auto& select() const noexcept {
 #endif
-      return capture_not_exists;
+    return capture_not_exists;
 }
 }
 ;
@@ -6388,9 +5467,9 @@ struct captures<> {
 template <typename Iterator, typename... Captures>
 class regex_results {
   captures<
-      captured_content<0>::template storage<Iterator>,
-      typename Captures::template storage<Iterator>...>
-      _captures {};
+    captured_content<0>::template storage<Iterator>,
+    typename Captures::template storage<Iterator>...>
+    _captures {};
 
  public:
   using char_type = typename std::iterator_traits<Iterator>::value_type;
@@ -6399,35 +5478,31 @@ class regex_results {
   constexpr CTRE_FORCE_INLINE regex_results(not_matched_tag_t) noexcept {}
 
   // special constructor for deducting
-  constexpr CTRE_FORCE_INLINE
-  regex_results(Iterator, ctll::list<Captures...>) noexcept {}
+  constexpr CTRE_FORCE_INLINE regex_results(Iterator, ctll::list<Captures...>) noexcept {}
 
-  template <
-      size_t Id,
-      typename = std::enable_if_t<decltype(_captures)::template exists<Id>()>>
+  template <size_t Id, typename = std::enable_if_t<decltype(_captures)::template exists<Id>()>>
   CTRE_FORCE_INLINE constexpr auto get() const noexcept {
     return _captures.template select<Id>();
   }
   template <
-      typename Name,
-      typename = std::enable_if_t<decltype(_captures)::template exists<Name>()>>
+    typename Name,
+    typename = std::enable_if_t<decltype(_captures)::template exists<Name>()>>
   CTRE_FORCE_INLINE constexpr auto get() const noexcept {
     return _captures.template select<Name>();
   }
 #if CTRE_CNTTP_COMPILER_CHECK
   template <
-      ctll::fixed_string Name,
-      typename = std::enable_if_t<decltype(_captures)::template exists<Name>()>>
+    ctll::fixed_string Name,
+    typename = std::enable_if_t<decltype(_captures)::template exists<Name>()>>
   CTRE_FORCE_INLINE constexpr auto get() const noexcept {
 #else
     template <
-        const auto& Name,
-        typename =
-            std::enable_if_t<decltype(_captures)::template exists<Name>()>>
+      const auto& Name,
+      typename = std::enable_if_t<decltype(_captures)::template exists<Name>()>>
     CTRE_FORCE_INLINE constexpr auto get() const noexcept {
 #endif
-      return _captures.template select<Name>();
-} static constexpr size_t count() noexcept { return sizeof...(Captures) + 1; }
+    return _captures.template select<Name>();
+} static constexpr size_t                  count() noexcept { return sizeof...(Captures) + 1; }
 constexpr CTRE_FORCE_INLINE regex_results& matched() noexcept {
   _captures.template select<0>().matched();
   return *this;
@@ -6440,13 +5515,11 @@ constexpr CTRE_FORCE_INLINE operator bool() const noexcept {
   return bool(_captures.template select<0>());
 }
 
-constexpr CTRE_FORCE_INLINE operator std::basic_string_view<char_type>(
-) const noexcept {
+constexpr CTRE_FORCE_INLINE operator std::basic_string_view<char_type>() const noexcept {
   return to_view();
 }
 
-constexpr CTRE_FORCE_INLINE explicit operator std::basic_string<char_type>(
-) const noexcept {
+constexpr CTRE_FORCE_INLINE explicit operator std::basic_string<char_type>() const noexcept {
   return to_string();
 }
 
@@ -6481,8 +5554,7 @@ constexpr CTRE_FORCE_INLINE const auto* data() const noexcept {
   return _captures.template select<0>().data();
 }
 
-constexpr CTRE_FORCE_INLINE regex_results& set_start_mark(Iterator pos
-) noexcept {
+constexpr CTRE_FORCE_INLINE regex_results& set_start_mark(Iterator pos) noexcept {
   _captures.template select<0>().set_start(pos);
   return *this;
 }
@@ -6494,8 +5566,7 @@ constexpr CTRE_FORCE_INLINE Iterator get_end_position() const noexcept {
   return _captures.template select<0>().get_end();
 }
 template <size_t Id>
-CTRE_FORCE_INLINE constexpr regex_results& start_capture(Iterator pos
-) noexcept {
+CTRE_FORCE_INLINE constexpr regex_results& start_capture(Iterator pos) noexcept {
   _captures.template select<Id>().set_start(pos);
   return *this;
 }
@@ -6504,58 +5575,41 @@ CTRE_FORCE_INLINE constexpr regex_results& end_capture(Iterator pos) noexcept {
   _captures.template select<Id>().set_end(pos).matched();
   return *this;
 }
-constexpr auto begin() const noexcept {
-  return _captures.template select<0>().begin();
-}
-constexpr auto end() const noexcept {
-  return _captures.template select<0>().end();
-}
-friend CTRE_FORCE_INLINE constexpr bool operator==(
-    const regex_results&              lhs,
-    std::basic_string_view<char_type> rhs
-) noexcept {
+constexpr auto begin() const noexcept { return _captures.template select<0>().begin(); }
+constexpr auto end() const noexcept { return _captures.template select<0>().end(); }
+friend CTRE_FORCE_INLINE constexpr bool
+operator==(const regex_results& lhs, std::basic_string_view<char_type> rhs) noexcept {
   return bool(lhs) ? lhs.view() == rhs : false;
 }
-friend CTRE_FORCE_INLINE constexpr bool operator!=(
-    const regex_results&              lhs,
-    std::basic_string_view<char_type> rhs
-) noexcept {
+friend CTRE_FORCE_INLINE constexpr bool
+operator!=(const regex_results& lhs, std::basic_string_view<char_type> rhs) noexcept {
   return bool(lhs) ? lhs.view() != rhs : true;
 }
-friend CTRE_FORCE_INLINE constexpr bool operator==(
-    std::basic_string_view<char_type> lhs,
-    const regex_results&              rhs
-) noexcept {
+friend CTRE_FORCE_INLINE constexpr bool
+operator==(std::basic_string_view<char_type> lhs, const regex_results& rhs) noexcept {
   return bool(rhs) ? lhs == rhs.view() : false;
 }
-friend CTRE_FORCE_INLINE constexpr bool operator!=(
-    std::basic_string_view<char_type> lhs,
-    const regex_results&              rhs
-) noexcept {
+friend CTRE_FORCE_INLINE constexpr bool
+operator!=(std::basic_string_view<char_type> lhs, const regex_results& rhs) noexcept {
   return bool(rhs) ? lhs != rhs.view() : true;
 }
-friend CTRE_FORCE_INLINE std::ostream&
-operator<<(std::ostream& str, const regex_results& rhs) {
+friend CTRE_FORCE_INLINE std::ostream& operator<<(std::ostream& str, const regex_results& rhs) {
   return str << rhs.view();
 }
 }
 ;
 
 template <size_t Id, typename Iterator, typename... Captures>
-constexpr auto get(const regex_results<Iterator, Captures...>& results
-) noexcept {
+constexpr auto get(const regex_results<Iterator, Captures...>& results) noexcept {
   return results.template get<Id>();
 }
 
 template <typename Iterator, typename... Captures>
-regex_results(Iterator, ctll::list<Captures...>)
-    -> regex_results<Iterator, Captures...>;
+regex_results(Iterator, ctll::list<Captures...>) -> regex_results<Iterator, Captures...>;
 
 template <typename ResultIterator, typename Pattern>
-using return_type = decltype(regex_results(
-    std::declval<ResultIterator>(),
-    find_captures(Pattern {})
-));
+using return_type =
+  decltype(regex_results(std::declval<ResultIterator>(), find_captures(Pattern {})));
 
 } // namespace ctre
 
@@ -6570,16 +5624,13 @@ using return_type = decltype(regex_results(
 namespace std {
   template <typename... Captures>
   struct tuple_size<ctre::regex_results<Captures...>>
-      : public std::integral_constant<
-            size_t,
-            ctre::regex_results<Captures...>::count()> {};
+    : public std::integral_constant<size_t, ctre::regex_results<Captures...>::count()> {};
 
   template <size_t N, typename... Captures>
   struct tuple_element<N, ctre::regex_results<Captures...>> {
    public:
     using type =
-        decltype(std::declval<const ctre::regex_results<Captures...>&>()
-                     .template get<N>());
+      decltype(std::declval<const ctre::regex_results<Captures...>&>().template get<N>());
   };
 } // namespace std
 
@@ -6601,204 +5652,133 @@ namespace ctre {
   }
 
   template <typename... Output>
-  constexpr auto
-  find_captures(ctll::list<>, ctll::list<Output...> output) noexcept {
+  constexpr auto find_captures(ctll::list<>, ctll::list<Output...> output) noexcept {
     return output;
   }
 
   template <auto... String, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<string<String...>, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto find_captures(ctll::list<string<String...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Tail...>(), output);
   }
 
   template <typename... Options, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<select<Options...>, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto find_captures(ctll::list<select<Options...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Options..., Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<optional<Content...>, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto find_captures(ctll::list<optional<Content...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Content..., Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<lazy_optional<Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<sequence<Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <typename... Tail, typename Output>
   constexpr auto
-  find_captures(ctll::list<empty, Tail...>, Output output) noexcept {
+  find_captures(ctll::list<lazy_optional<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <typename... Content, typename... Tail, typename Output>
+  constexpr auto find_captures(ctll::list<sequence<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <typename... Tail, typename Output>
+  constexpr auto find_captures(ctll::list<empty, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Tail...>(), output);
   }
 
   template <typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<assert_subject_begin, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto find_captures(ctll::list<assert_subject_begin, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Tail...>(), output);
   }
 
   template <typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<assert_subject_end, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto find_captures(ctll::list<assert_subject_end, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Tail...>(), output);
   }
 
   // , typename = std::enable_if_t<(MatchesCharacter<CharacterLike>::template
   // value<char>)
   template <typename CharacterLike, typename... Tail, typename Output>
-  constexpr auto
-  find_captures(ctll::list<CharacterLike, Tail...>, Output output) noexcept {
+  constexpr auto find_captures(ctll::list<CharacterLike, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
+  constexpr auto find_captures(ctll::list<plus<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <typename... Content, typename... Tail, typename Output>
+  constexpr auto find_captures(ctll::list<star<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <size_t A, size_t B, typename... Content, typename... Tail, typename Output>
   constexpr auto
-  find_captures(ctll::list<plus<Content...>, Tail...>, Output output) noexcept {
+  find_captures(ctll::list<repeat<A, B, Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <typename... Content, typename... Tail, typename Output>
+  constexpr auto find_captures(ctll::list<lazy_plus<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <typename... Content, typename... Tail, typename Output>
+  constexpr auto find_captures(ctll::list<lazy_star<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <size_t A, size_t B, typename... Content, typename... Tail, typename Output>
+  constexpr auto
+  find_captures(ctll::list<lazy_repeat<A, B, Content...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Content..., Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
   constexpr auto
-  find_captures(ctll::list<star<Content...>, Tail...>, Output output) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail,
-      typename Output>
-  constexpr auto find_captures(
-      ctll::list<repeat<A, B, Content...>, Tail...>,
-      Output output
-  ) noexcept {
+  find_captures(ctll::list<possessive_plus<Content...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Content..., Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<lazy_plus<Content...>, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto
+  find_captures(ctll::list<possessive_star<Content...>, Tail...>, Output output) noexcept {
+    return find_captures(ctll::list<Content..., Tail...>(), output);
+  }
+
+  template <size_t A, size_t B, typename... Content, typename... Tail, typename Output>
+  constexpr auto
+  find_captures(ctll::list<possessive_repeat<A, B, Content...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Content..., Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<lazy_star<Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail,
-      typename Output>
-  constexpr auto find_captures(
-      ctll::list<lazy_repeat<A, B, Content...>, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto
+  find_captures(ctll::list<lookahead_positive<Content...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Content..., Tail...>(), output);
   }
 
   template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<possessive_plus<Content...>, Tail...>,
-      Output output
-  ) noexcept {
+  constexpr auto
+  find_captures(ctll::list<lookahead_negative<Content...>, Tail...>, Output output) noexcept {
     return find_captures(ctll::list<Content..., Tail...>(), output);
   }
 
-  template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<possessive_star<Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail,
-      typename Output>
-  constexpr auto find_captures(
-      ctll::list<possessive_repeat<A, B, Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<lookahead_positive<Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <typename... Content, typename... Tail, typename Output>
-  constexpr auto find_captures(
-      ctll::list<lookahead_negative<Content...>, Tail...>,
-      Output output
-  ) noexcept {
-    return find_captures(ctll::list<Content..., Tail...>(), output);
-  }
-
-  template <
-      size_t Id,
-      typename... Content,
-      typename... Tail,
-      typename... Output>
+  template <size_t Id, typename... Content, typename... Tail, typename... Output>
   constexpr auto
   find_captures(ctll::list<capture<Id, Content...>, Tail...>, ctll::list<Output...>) noexcept {
     return find_captures(
-        ctll::list<Content..., Tail...>(),
-        ctll::list<Output..., captured_content<Id>>()
+      ctll::list<Content..., Tail...>(), ctll::list<Output..., captured_content<Id>>()
     );
   }
 
-  template <
-      size_t Id,
-      typename Name,
-      typename... Content,
-      typename... Tail,
-      typename... Output>
+  template <size_t Id, typename Name, typename... Content, typename... Tail, typename... Output>
   constexpr auto
   find_captures(ctll::list<capture_with_name<Id, Name, Content...>, Tail...>, ctll::list<Output...>) noexcept {
     return find_captures(
-        ctll::list<Content..., Tail...>(),
-        ctll::list<Output..., captured_content<Id, Name>>()
+      ctll::list<Content..., Tail...>(), ctll::list<Output..., captured_content<Id, Name>>()
     );
   }
 
@@ -6819,46 +5799,39 @@ namespace ctre {
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<accept, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<accept, Tail...>) noexcept {
     return l;
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<end_mark, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<end_mark, Tail...>) noexcept {
     return l;
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<end_cycle_mark, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<end_cycle_mark, Tail...>) noexcept {
     return l;
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<end_lookahead_mark, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<end_lookahead_mark, Tail...>) noexcept {
     return l;
   }
 
   template <typename... Content, size_t Id, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<numeric_mark<Id>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<numeric_mark<Id>, Tail...>) noexcept {
     return first(l, ctll::list<Tail...> {});
   }
 
   // empty
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<empty, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<empty, Tail...>) noexcept {
     return first(l, ctll::list<Tail...> {});
   }
 
   // boundary
   template <typename... Content, typename CharLike, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<boundary<CharLike>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<boundary<CharLike>, Tail...>) noexcept {
     return first(l, ctll::list<Tail...> {});
   }
 
@@ -6870,8 +5843,7 @@ namespace ctre {
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<assert_subject_end, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<assert_subject_end, Tail...>) noexcept {
     return l;
   }
 
@@ -6883,23 +5855,20 @@ namespace ctre {
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<assert_line_begin, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<assert_line_begin, Tail...>) noexcept {
     // FIXME line begin is a bit different than subject begin
     return first(l, ctll::list<Tail...> {});
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<assert_line_end, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<assert_line_end, Tail...>) noexcept {
     // FIXME line end is a bit different than subject begin
     return l;
   }
 
   // sequence
   template <typename... Content, typename... Seq, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<sequence<Seq...>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<sequence<Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
   }
 
@@ -6912,15 +5881,13 @@ namespace ctre {
 
   // plus
   template <typename... Content, typename... Seq, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<plus<Seq...>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<plus<Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
   }
 
   // lazy_plus
   template <typename... Content, typename... Seq, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<lazy_plus<Seq...>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<lazy_plus<Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
   }
 
@@ -6933,38 +5900,25 @@ namespace ctre {
 
   // star
   template <typename... Content, typename... Seq, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<star<Seq...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {}
-    );
+  constexpr auto first(ctll::list<Content...> l, ctll::list<star<Seq...>, Tail...>) noexcept {
+    return first(first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {});
   }
 
   // lazy_star
   template <typename... Content, typename... Seq, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<lazy_star<Seq...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {}
-    );
+  constexpr auto first(ctll::list<Content...> l, ctll::list<lazy_star<Seq...>, Tail...>) noexcept {
+    return first(first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {});
   }
 
   // possessive_star
   template <typename... Content, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<possessive_star<Seq...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {}
-    );
+    return first(first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {});
   }
 
   // lazy_repeat
-  template <
-      typename... Content,
-      size_t A,
-      size_t B,
-      typename... Seq,
-      typename... Tail>
+  template <typename... Content, size_t A, size_t B, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<lazy_repeat<A, B, Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
@@ -6973,18 +5927,11 @@ namespace ctre {
   template <typename... Content, size_t B, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<lazy_repeat<0, B, Seq...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {}
-    );
+    return first(first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {});
   }
 
   // possessive_repeat
-  template <
-      typename... Content,
-      size_t A,
-      size_t B,
-      typename... Seq,
-      typename... Tail>
+  template <typename... Content, size_t A, size_t B, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<possessive_repeat<A, B, Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
@@ -6993,18 +5940,11 @@ namespace ctre {
   template <typename... Content, size_t B, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<possessive_repeat<0, B, Seq...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {}
-    );
+    return first(first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {});
   }
 
   // repeat
-  template <
-      typename... Content,
-      size_t A,
-      size_t B,
-      typename... Seq,
-      typename... Tail>
+  template <typename... Content, size_t A, size_t B, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<repeat<A, B, Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
@@ -7013,9 +5953,7 @@ namespace ctre {
   template <typename... Content, size_t B, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<repeat<0, B, Seq...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {}
-    );
+    return first(first(l, ctll::list<Tail...> {}), ctll::list<Seq..., Tail...> {});
   }
 
   // lookahead_positive
@@ -7053,12 +5991,7 @@ namespace ctre {
     return first(l, ctll::list<Seq..., Tail...> {});
   }
 
-  template <
-      typename... Content,
-      size_t Id,
-      typename Name,
-      typename... Seq,
-      typename... Tail>
+  template <typename... Content, size_t Id, typename Name, typename... Seq, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<capture_with_name<Id, Name, Seq...>, Tail...>) noexcept {
     return first(l, ctll::list<Seq..., Tail...> {});
@@ -7066,8 +5999,7 @@ namespace ctre {
 
   // backreference
   template <typename... Content, size_t Id, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...>, ctll::list<back_reference<Id>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...>, ctll::list<back_reference<Id>, Tail...>) noexcept {
     return ctll::list<can_be_anything> {};
   }
 
@@ -7085,65 +6017,47 @@ namespace ctre {
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<string<>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<string<>, Tail...>) noexcept {
     return first(l, ctll::list<Tail...> {});
   }
 
   // optional
   template <typename... Content, typename... Opt, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<optional<Opt...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Opt..., Tail...> {}), ctll::list<Tail...> {}
-    );
+  constexpr auto first(ctll::list<Content...> l, ctll::list<optional<Opt...>, Tail...>) noexcept {
+    return first(first(l, ctll::list<Opt..., Tail...> {}), ctll::list<Tail...> {});
   }
 
   template <typename... Content, typename... Opt, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<lazy_optional<Opt...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<Opt..., Tail...> {}), ctll::list<Tail...> {}
-    );
+    return first(first(l, ctll::list<Opt..., Tail...> {}), ctll::list<Tail...> {});
   }
 
   // select (alternation)
-  template <
-      typename... Content,
-      typename SHead,
-      typename... STail,
-      typename... Tail>
+  template <typename... Content, typename SHead, typename... STail, typename... Tail>
   constexpr auto
   first(ctll::list<Content...> l, ctll::list<select<SHead, STail...>, Tail...>) noexcept {
-    return first(
-        first(l, ctll::list<SHead, Tail...> {}),
-        ctll::list<select<STail...>, Tail...> {}
-    );
+    return first(first(l, ctll::list<SHead, Tail...> {}), ctll::list<select<STail...>, Tail...> {});
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...> l, ctll::list<select<>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...> l, ctll::list<select<>, Tail...>) noexcept {
     return l;
   }
 
   // unicode property => anything
-  template <
-      typename... Content,
-      typename PropertyType,
-      PropertyType Property,
-      typename... Tail>
+  template <typename... Content, typename PropertyType, PropertyType Property, typename... Tail>
   constexpr auto
   first(ctll::list<Content...>, ctll::list<ctre::binary_property<PropertyType, Property>, Tail...>) noexcept {
     return ctll::list<can_be_anything> {};
   }
 
   template <
-      typename... Content,
-      typename PropertyType,
-      PropertyType Property,
-      auto         Value,
-      typename... Tail>
+    typename... Content,
+    typename PropertyType,
+    PropertyType Property,
+    auto         Value,
+    typename... Tail>
   constexpr auto
   first(ctll::list<Content...>, ctll::list<ctre::property<PropertyType, Property, Value>, Tail...>) noexcept {
     return ctll::list<can_be_anything> {};
@@ -7152,8 +6066,7 @@ namespace ctre {
   // characters / sets
 
   template <typename... Content, auto V, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...>, ctll::list<character<V>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...>, ctll::list<character<V>, Tail...>) noexcept {
     return ctll::list<Content..., character<V>> {};
   }
 
@@ -7164,20 +6077,17 @@ namespace ctre {
   }
 
   template <typename... Content, typename... SetContent, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...>, ctll::list<set<SetContent...>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...>, ctll::list<set<SetContent...>, Tail...>) noexcept {
     return ctll::list<Content..., SetContent...> {};
   }
 
   template <typename... Content, auto A, auto B, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...>, ctll::list<char_range<A, B>, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...>, ctll::list<char_range<A, B>, Tail...>) noexcept {
     return ctll::list<Content..., char_range<A, B>> {};
   }
 
   template <typename... Content, typename... Tail>
-  constexpr auto
-  first(ctll::list<Content...>, ctll::list<any, Tail...>) noexcept {
+  constexpr auto first(ctll::list<Content...>, ctll::list<any, Tail...>) noexcept {
     return ctll::list<can_be_anything> {};
   }
 
@@ -7226,7 +6136,9 @@ namespace ctre {
   template <auto A, typename CB>
   constexpr int64_t negative_helper(ctre::character<A>, CB& cb, int64_t start) {
     if (A != (std::numeric_limits<int64_t>::min)()) {
-      if (start < A) { cb(start, A - 1); }
+      if (start < A) {
+        cb(start, A - 1);
+      }
     }
     if (A != (std::numeric_limits<int64_t>::max)()) {
       return A + 1;
@@ -7236,10 +6148,11 @@ namespace ctre {
   }
 
   template <auto A, auto B, typename CB>
-  constexpr int64_t
-  negative_helper(ctre::char_range<A, B>, CB& cb, int64_t start) {
+  constexpr int64_t negative_helper(ctre::char_range<A, B>, CB& cb, int64_t start) {
     if (A != (std::numeric_limits<int64_t>::min)()) {
-      if (start < A) { cb(start, A - 1); }
+      if (start < A) {
+        cb(start, A - 1);
+      }
     }
     if (B != (std::numeric_limits<int64_t>::max)()) {
       return B + 1;
@@ -7249,8 +6162,7 @@ namespace ctre {
   }
 
   template <auto Head, auto... Tail, typename CB>
-  constexpr int64_t
-  negative_helper(ctre::enumeration<Head, Tail...>, CB& cb, int64_t start) {
+  constexpr int64_t negative_helper(ctre::enumeration<Head, Tail...>, CB& cb, int64_t start) {
     int64_t nstart = negative_helper(ctre::character<Head> {}, cb, start);
     return negative_helper(ctre::enumeration<Tail...> {}, cb, nstart);
   }
@@ -7266,51 +6178,38 @@ namespace ctre {
   }
 
   template <typename PropertyType, PropertyType Property, typename CB>
-  constexpr auto negative_helper(
-      ctre::binary_property<PropertyType, Property>,
-      CB&&,
-      int64_t start
-  ) {
+  constexpr auto
+  negative_helper(ctre::binary_property<PropertyType, Property>, CB&&, int64_t start) {
     return start;
   }
 
-  template <
-      typename PropertyType,
-      PropertyType Property,
-      auto         Value,
-      typename CB>
-  constexpr auto negative_helper(
-      ctre::property<PropertyType, Property, Value>,
-      CB&&,
-      int64_t start
-  ) {
+  template <typename PropertyType, PropertyType Property, auto Value, typename CB>
+  constexpr auto
+  negative_helper(ctre::property<PropertyType, Property, Value>, CB&&, int64_t start) {
     return start;
   }
 
   template <typename Head, typename... Rest, typename CB>
-  constexpr int64_t
-  negative_helper(ctre::set<Head, Rest...>, CB& cb, int64_t start) {
+  constexpr int64_t negative_helper(ctre::set<Head, Rest...>, CB& cb, int64_t start) {
     start = negative_helper(Head {}, cb, start);
     return negative_helper(ctre::set<Rest...> {}, cb, start);
   }
 
   template <typename Head, typename... Rest, typename CB>
   constexpr void negative_helper(
-      ctre::negative_set<Head, Rest...>,
-      CB&&    cb,
-      int64_t start = (std::numeric_limits<int64_t>::min)()
+    ctre::negative_set<Head, Rest...>,
+    CB&&    cb,
+    int64_t start = (std::numeric_limits<int64_t>::min)()
   ) {
     start = negative_helper(Head {}, cb, start);
-    negative_helper(
-        ctre::negative_set<Rest...> {}, std::forward<CB>(cb), start
-    );
+    negative_helper(ctre::negative_set<Rest...> {}, std::forward<CB>(cb), start);
   }
 
   template <typename CB>
   constexpr void negative_helper(
-      ctre::negative_set<>,
-      CB&&    cb,
-      int64_t start = (std::numeric_limits<int64_t>::min)()
+    ctre::negative_set<>,
+    CB&&    cb,
+    int64_t start = (std::numeric_limits<int64_t>::min)()
   ) {
     if (start < (std::numeric_limits<int64_t>::max)()) {
       cb(start, (std::numeric_limits<int64_t>::max)());
@@ -7326,10 +6225,10 @@ namespace ctre {
       int64_t        high {};
       constexpr bool operator<(const point& rhs) const { return low < rhs.low; }
       constexpr point() {}
-      constexpr point(int64_t l, int64_t h) : low {l}, high {h} {}
+      constexpr point(int64_t l, int64_t h) : low { l }, high { h } {}
     };
     point            points[Capacity + 1] {};
-    size_t           used {0};
+    size_t           used { 0 };
     constexpr point* begin() { return points; }
     constexpr point* begin() const { return points; }
     constexpr point* end() { return points + used; }
@@ -7353,7 +6252,7 @@ namespace ctre {
       return it;
     }
     constexpr point* insert_point(int64_t position, int64_t other) {
-      point obj {position, other};
+      point obj { position, other };
       auto  it = lower_bound(obj);
       if (it == end()) {
         *it = obj;
@@ -7445,9 +6344,7 @@ namespace ctre {
     }
     template <typename... Content>
     constexpr void populate(ctre::negative_set<Content...> nset) {
-      negative_helper(nset, [&](int64_t low, int64_t high) {
-        this->insert(low, high);
-      });
+      negative_helper(nset, [&](int64_t low, int64_t high) { this->insert(low, high); });
     }
     template <typename... Content>
     constexpr void populate(ctre::set<Content...>) {
@@ -7485,9 +6382,7 @@ namespace ctre {
 namespace ctre {
 
   template <size_t Limit>
-  constexpr CTRE_FORCE_INLINE bool less_than_or_infinite(
-      [[maybe_unused]] size_t i
-  ) noexcept {
+  constexpr CTRE_FORCE_INLINE bool less_than_or_infinite([[maybe_unused]] size_t i) noexcept {
     if constexpr (Limit == 0) {
       // infinite
       return true;
@@ -7497,8 +6392,7 @@ namespace ctre {
   }
 
   template <size_t Limit>
-  constexpr CTRE_FORCE_INLINE bool less_than([[maybe_unused]] size_t i
-  ) noexcept {
+  constexpr CTRE_FORCE_INLINE bool less_than([[maybe_unused]] size_t i) noexcept {
     if constexpr (Limit == 0) {
       // infinite
       return false;
@@ -7507,34 +6401,18 @@ namespace ctre {
     }
   }
 
-  constexpr bool is_bidirectional(const std::bidirectional_iterator_tag&) {
-    return true;
-  }
+  constexpr bool is_bidirectional(const std::bidirectional_iterator_tag&) { return true; }
   constexpr bool is_bidirectional(...) { return false; }
 
   // sink for making the errors shorter
-  template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator>
-  constexpr CTRE_FORCE_INLINE R evaluate(
-      const BeginIterator,
-      Iterator,
-      const EndIterator,
-      flags,
-      R,
-      ...
-  ) noexcept {
+  template <typename R, typename BeginIterator, typename Iterator, typename EndIterator>
+  constexpr CTRE_FORCE_INLINE R
+  evaluate(const BeginIterator, Iterator, const EndIterator, flags, R, ...) noexcept {
     return not_matched;
   }
 
   // if we found "accept" object on stack => ACCEPT
-  template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator>
+  template <typename R, typename BeginIterator, typename Iterator, typename EndIterator>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator, Iterator, const EndIterator, flags, R captures, ctll::list<accept>) noexcept {
     return captures.matched();
@@ -7542,11 +6420,11 @@ namespace ctre {
 
   // if we found "reject" object on stack => REJECT
   template <
-      typename R,
-      typename... Rest,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator>
+    typename R,
+    typename... Rest,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator, Iterator, const EndIterator, flags, R, ctll::list<reject, Rest...>) noexcept {
     return not_matched;
@@ -7554,44 +6432,42 @@ namespace ctre {
 
   // mark start of outer capture
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<start_mark, Tail...>) noexcept {
     return evaluate(
-        begin, current, last, f, captures.set_start_mark(current),
-        ctll::list<Tail...>()
+      begin, current, last, f, captures.set_start_mark(current), ctll::list<Tail...>()
     );
   }
 
   // mark end of outer capture
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<end_mark, Tail...>) noexcept {
-    return evaluate(
-        begin, current, last, f, captures.set_end_mark(current),
-        ctll::list<Tail...>()
-    );
+    return evaluate(begin, current, last, f, captures.set_end_mark(current), ctll::list<Tail...>());
   }
 
   // mark end of cycle
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator, Iterator current, const EndIterator, [[maybe_unused]] const flags& f, R captures, ctll::list<end_cycle_mark>) noexcept {
-    if (cannot_be_empty_match(f)) { return not_matched; }
+    if (cannot_be_empty_match(f)) {
+      return not_matched;
+    }
 
     return captures.set_end_mark(current).matched();
   }
@@ -7599,107 +6475,103 @@ namespace ctre {
   // matching everything which behave as a one character matcher
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename CharacterLike,
-      typename... Tail,
-      typename =
-          std::enable_if_t<(MatchesCharacter<CharacterLike>::template value<
-                            decltype(*std::declval<Iterator>())>)>>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename CharacterLike,
+    typename... Tail,
+    typename = std::enable_if_t<
+      (MatchesCharacter<CharacterLike>::template value<decltype(*std::declval<Iterator>())>)>>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<CharacterLike, Tail...>) noexcept {
-    if (current == last) return not_matched;
-    if (!CharacterLike::match_char(*current, f)) return not_matched;
+    if (current == last)
+      return not_matched;
+    if (!CharacterLike::match_char(*current, f))
+      return not_matched;
 
-    return evaluate(
-        begin, ++current, last, consumed_something(f), captures,
-        ctll::list<Tail...>()
-    );
+    return evaluate(begin, ++current, last, consumed_something(f), captures, ctll::list<Tail...>());
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<any, Tail...>) noexcept {
-    if (current == last) return not_matched;
+    if (current == last)
+      return not_matched;
 
     if (multiline_mode(f)) {
       // TODO add support for different line ending and unicode (in a future
       // unicode mode)
-      if (*current == '\n') return not_matched;
+      if (*current == '\n')
+        return not_matched;
     }
-    return evaluate(
-        begin, ++current, last, consumed_something(f), captures,
-        ctll::list<Tail...>()
-    );
+    return evaluate(begin, ++current, last, consumed_something(f), captures, ctll::list<Tail...>());
   }
 
   // matching strings in patterns
   template <auto... String, typename Iterator, typename EndIterator>
   constexpr CTRE_FORCE_INLINE bool match_string(
-      [[maybe_unused]] Iterator&         current,
-      [[maybe_unused]] const EndIterator last,
-      [[maybe_unused]] const flags&      f
+    [[maybe_unused]] Iterator&         current,
+    [[maybe_unused]] const EndIterator last,
+    [[maybe_unused]] const flags&      f
   ) {
-    return (
-        (current != last && character<String>::match_char(*current++, f)) &&
-        ... && true
-    );
+    return ((current != last && character<String>::match_char(*current++, f)) && ... && true);
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      auto... String,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    auto... String,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, [[maybe_unused]] const flags& f, R captures, ctll::list<string<String...>, Tail...>) noexcept {
-    if (!match_string<String...>(current, last, f)) { return not_matched; }
+    if (!match_string<String...>(current, last, f)) {
+      return not_matched;
+    }
 
     return evaluate(
-        begin, current, last, consumed_something(f, sizeof...(String) > 0),
-        captures, ctll::list<Tail...>()
+      begin,
+      current,
+      last,
+      consumed_something(f, sizeof...(String) > 0),
+      captures,
+      ctll::list<Tail...>()
     );
   }
 
   // matching select in patterns
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename HeadOptions,
-      typename... TailOptions,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename HeadOptions,
+    typename... TailOptions,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<select<HeadOptions, TailOptions...>, Tail...>) noexcept {
-    if (auto r = evaluate(
-            begin, current, last, f, captures,
-            ctll::list<HeadOptions, Tail...>()
-        )) {
+    if (auto r = evaluate(begin, current, last, f, captures, ctll::list<HeadOptions, Tail...>())) {
       return r;
     } else {
       return evaluate(
-          begin, current, last, f, captures,
-          ctll::list<select<TailOptions...>, Tail...>()
+        begin, current, last, f, captures, ctll::list<select<TailOptions...>, Tail...>()
       );
     }
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator, Iterator, const EndIterator, flags, R, ctll::list<select<>, Tail...>) noexcept {
     // no previous option was matched => REJECT
@@ -7708,34 +6580,36 @@ namespace ctre {
 
   // matching sequence in patterns
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename HeadContent,
-      typename... TailContent,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename HeadContent,
+    typename... TailContent,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<sequence<HeadContent, TailContent...>, Tail...>) noexcept {
     if constexpr (sizeof...(TailContent) > 0) {
       return evaluate(
-          begin, current, last, f, captures,
-          ctll::list<HeadContent, sequence<TailContent...>, Tail...>()
+        begin,
+        current,
+        last,
+        f,
+        captures,
+        ctll::list<HeadContent, sequence<TailContent...>, Tail...>()
       );
     } else {
-      return evaluate(
-          begin, current, last, f, captures, ctll::list<HeadContent, Tail...>()
-      );
+      return evaluate(begin, current, last, f, captures, ctll::list<HeadContent, Tail...>());
     }
   }
 
   // matching empty in patterns
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<empty, Tail...>) noexcept {
     return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
@@ -7743,116 +6617,114 @@ namespace ctre {
 
   // matching asserts
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<assert_subject_begin, Tail...>) noexcept {
-    if (begin != current) { return not_matched; }
+    if (begin != current) {
+      return not_matched;
+    }
     return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<assert_subject_end, Tail...>) noexcept {
-    if (last != current) { return not_matched; }
+    if (last != current) {
+      return not_matched;
+    }
     return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<assert_subject_end_line, Tail...>) noexcept {
     if (multiline_mode(f)) {
       if (last == current) {
-        return evaluate(
-            begin, current, last, f, captures, ctll::list<Tail...>()
-        );
+        return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
       } else if (*current == '\n' && std::next(current) == last) {
-        return evaluate(
-            begin, current, last, f, captures, ctll::list<Tail...>()
-        );
+        return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
       } else {
         return not_matched;
       }
     } else {
-      if (last != current) { return not_matched; }
+      if (last != current) {
+        return not_matched;
+      }
       return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
     }
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<assert_line_begin, Tail...>) noexcept {
     if (multiline_mode(f)) {
       if (begin == current) {
-        return evaluate(
-            begin, current, last, f, captures, ctll::list<Tail...>()
-        );
+        return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
       } else if (*std::prev(current) == '\n') {
-        return evaluate(
-            begin, current, last, f, captures, ctll::list<Tail...>()
-        );
+        return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
       } else {
         return not_matched;
       }
     } else {
-      if (begin != current) { return not_matched; }
+      if (begin != current) {
+        return not_matched;
+      }
       return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
     }
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<assert_line_end, Tail...>) noexcept {
     if (multiline_mode(f)) {
       if (last == current) {
-        return evaluate(
-            begin, current, last, f, captures, ctll::list<Tail...>()
-        );
+        return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
       } else if (*current == '\n') {
-        return evaluate(
-            begin, current, last, f, captures, ctll::list<Tail...>()
-        );
+        return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
       } else {
         return not_matched;
       }
     }
 
     // TODO properly match line end
-    if (last != current) { return not_matched; }
+    if (last != current) {
+      return not_matched;
+    }
     return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
   }
 
   // matching boundary
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename CharacterLike,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename CharacterLike,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<boundary<CharacterLike>, Tail...>) noexcept {
     // reason why I need bidirectional iterators or some clever hack
@@ -7860,31 +6732,32 @@ namespace ctre {
     bool after  = false;
 
     static_assert(
-        is_bidirectional(
-            typename std::iterator_traits<Iterator>::iterator_category {}
-        ),
-        "To use boundary in regex you need to provide bidirectional iterator "
-        "or range."
+      is_bidirectional(typename std::iterator_traits<Iterator>::iterator_category {}),
+      "To use boundary in regex you need to provide bidirectional iterator "
+      "or range."
     );
 
-    if (last != current) { after = CharacterLike::match_char(*current, f); }
+    if (last != current) {
+      after = CharacterLike::match_char(*current, f);
+    }
     if (begin != current) {
       before = CharacterLike::match_char(*std::prev(current), f);
     }
 
-    if (before == after) return not_matched;
+    if (before == after)
+      return not_matched;
 
     return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
   }
 
   // matching not_boundary
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename CharacterLike,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename CharacterLike,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<not_boundary<CharacterLike>, Tail...>) noexcept {
     // reason why I need bidirectional iterators or some clever hack
@@ -7892,33 +6765,34 @@ namespace ctre {
     bool after  = false;
 
     static_assert(
-        is_bidirectional(
-            typename std::iterator_traits<Iterator>::iterator_category {}
-        ),
-        "To use boundary in regex you need to provide bidirectional iterator "
-        "or range."
+      is_bidirectional(typename std::iterator_traits<Iterator>::iterator_category {}),
+      "To use boundary in regex you need to provide bidirectional iterator "
+      "or range."
     );
 
-    if (last != current) { after = CharacterLike::match_char(*current, f); }
+    if (last != current) {
+      after = CharacterLike::match_char(*current, f);
+    }
     if (begin != current) {
       before = CharacterLike::match_char(*std::prev(current), f);
     }
 
-    if (before != after) return not_matched;
+    if (before != after)
+      return not_matched;
 
     return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
   }
 
   // lazy repeat
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t A,
+    size_t B,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, [[maybe_unused]] const flags& f, R captures, ctll::list<lazy_repeat<A, B, Content...>, Tail...>) noexcept {
     if constexpr (B != 0 && A > B) {
@@ -7926,15 +6800,20 @@ namespace ctre {
     } else {
       const Iterator backup_current = current;
 
-      size_t i {0};
+      size_t i { 0 };
 
       while (less_than<A>(i)) {
         auto outer_result = evaluate(
-            begin, current, last, not_empty_match(f), captures,
-            ctll::list<Content..., end_cycle_mark>()
+          begin,
+          current,
+          last,
+          not_empty_match(f),
+          captures,
+          ctll::list<Content..., end_cycle_mark>()
         );
 
-        if (!outer_result) return not_matched;
+        if (!outer_result)
+          return not_matched;
 
         captures = outer_result.unmatch();
         current  = outer_result.get_end_position();
@@ -7943,27 +6822,41 @@ namespace ctre {
       }
 
       if (auto outer_result = evaluate(
-              begin, current, last,
-              consumed_something(f, backup_current != current), captures,
-              ctll::list<Tail...>()
+            begin,
+            current,
+            last,
+            consumed_something(f, backup_current != current),
+            captures,
+            ctll::list<Tail...>()
           )) {
         return outer_result;
       }
 
       while (less_than_or_infinite<B>(i)) {
         auto inner_result = evaluate(
-            begin, current, last, not_empty_match(f), captures,
-            ctll::list<Content..., end_cycle_mark>()
+          begin,
+          current,
+          last,
+          not_empty_match(f),
+          captures,
+          ctll::list<Content..., end_cycle_mark>()
         );
 
-        if (!inner_result) return not_matched;
+        if (!inner_result)
+          return not_matched;
 
         auto outer_result = evaluate(
-            begin, inner_result.get_end_position(), last, consumed_something(f),
-            inner_result.unmatch(), ctll::list<Tail...>()
+          begin,
+          inner_result.get_end_position(),
+          last,
+          consumed_something(f),
+          inner_result.unmatch(),
+          ctll::list<Tail...>()
         );
 
-        if (outer_result) { return outer_result; }
+        if (outer_result) {
+          return outer_result;
+        }
 
         captures = inner_result.unmatch();
         current  = inner_result.get_end_position();
@@ -7972,23 +6865,20 @@ namespace ctre {
       }
 
       // rest of regex
-      return evaluate(
-          begin, current, last, consumed_something(f), captures,
-          ctll::list<Tail...>()
-      );
+      return evaluate(begin, current, last, consumed_something(f), captures, ctll::list<Tail...>());
     }
   }
 
   // possessive repeat
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t A,
+    size_t B,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, [[maybe_unused]] const flags& f, R captures, ctll::list<possessive_repeat<A, B, Content...>, Tail...>) noexcept {
     if constexpr ((B != 0) && (A > B)) {
@@ -7996,15 +6886,20 @@ namespace ctre {
     } else {
       const auto backup_current = current;
 
-      for (size_t i {0}; less_than_or_infinite<B>(i); ++i) {
+      for (size_t i { 0 }; less_than_or_infinite<B>(i); ++i) {
         // try as many of inner as possible and then try outer once
         auto inner_result = evaluate(
-            begin, current, last, not_empty_match(f), captures,
-            ctll::list<Content..., end_cycle_mark>()
+          begin,
+          current,
+          last,
+          not_empty_match(f),
+          captures,
+          ctll::list<Content..., end_cycle_mark>()
         );
 
         if (!inner_result) {
-          if (!less_than<A>(i)) break;
+          if (!less_than<A>(i))
+            break;
           return not_matched;
         }
 
@@ -8013,43 +6908,46 @@ namespace ctre {
       }
 
       return evaluate(
-          begin, current, last,
-          consumed_something(f, backup_current != current), captures,
-          ctll::list<Tail...>()
+        begin,
+        current,
+        last,
+        consumed_something(f, backup_current != current),
+        captures,
+        ctll::list<Tail...>()
       );
     }
   }
 
   // (gready) repeat
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t A,
+    size_t B,
+    typename... Content,
+    typename... Tail>
 #ifdef CTRE_MSVC_GREEDY_WORKAROUND
   constexpr inline void evaluate_recursive(
-      R&                                            result,
-      size_t                                        i,
-      const BeginIterator                           begin,
-      Iterator                                      current,
-      const EndIterator                             last,
-      [[maybe_unused]] const flags&                 f,
-      R                                             captures,
-      ctll::list<repeat<A, B, Content...>, Tail...> stack
+    R&                                            result,
+    size_t                                        i,
+    const BeginIterator                           begin,
+    Iterator                                      current,
+    const EndIterator                             last,
+    [[maybe_unused]] const flags&                 f,
+    R                                             captures,
+    ctll::list<repeat<A, B, Content...>, Tail...> stack
   ) noexcept {
 #else
   constexpr inline R evaluate_recursive(
-      size_t                                        i,
-      const BeginIterator                           begin,
-      Iterator                                      current,
-      const EndIterator                             last,
-      [[maybe_unused]] const flags&                 f,
-      R                                             captures,
-      ctll::list<repeat<A, B, Content...>, Tail...> stack
+    size_t                                        i,
+    const BeginIterator                           begin,
+    Iterator                                      current,
+    const EndIterator                             last,
+    [[maybe_unused]] const flags&                 f,
+    R                                             captures,
+    ctll::list<repeat<A, B, Content...>, Tail...> stack
   ) noexcept {
 #endif
     if (less_than_or_infinite<B>(i)) {
@@ -8057,8 +6955,12 @@ namespace ctre {
       // aab
 
       if (auto inner_result = evaluate(
-              begin, current, last, not_empty_match(f), captures,
-              ctll::list<Content..., end_cycle_mark>()
+            begin,
+            current,
+            last,
+            not_empty_match(f),
+            captures,
+            ctll::list<Content..., end_cycle_mark>()
           )) {
         // TODO MSVC issue:
         // if I uncomment this return it will not fail in constexpr (but the
@@ -8069,14 +6971,14 @@ namespace ctre {
         tmp_current      = inner_result.get_end_position();
 #ifdef CTRE_MSVC_GREEDY_WORKAROUND
         evaluate_recursive(
-            result, i + 1, begin, tmp_current, last, f, inner_result.unmatch(),
-            stack
+          result, i + 1, begin, tmp_current, last, f, inner_result.unmatch(), stack
         );
-        if (result) { return; }
+        if (result) {
+          return;
+        }
 #else
         if (auto rec_result = evaluate_recursive(
-                i + 1, begin, tmp_current, last, f, inner_result.unmatch(),
-                stack
+              i + 1, begin, tmp_current, last, f, inner_result.unmatch(), stack
             )) {
           return rec_result;
         }
@@ -8084,60 +6986,60 @@ namespace ctre {
       }
     }
 #ifdef CTRE_MSVC_GREEDY_WORKAROUND
-    result = evaluate(
-        begin, current, last, consumed_something(f), captures,
-        ctll::list<Tail...>()
-    );
+    result = evaluate(begin, current, last, consumed_something(f), captures, ctll::list<Tail...>());
 #else
-    return evaluate(
-        begin, current, last, consumed_something(f), captures,
-        ctll::list<Tail...>()
-    );
+    return evaluate(begin, current, last, consumed_something(f), captures, ctll::list<Tail...>());
 #endif
   }
 
   // (greedy) repeat
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t A,
-      size_t B,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t A,
+    size_t B,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R evaluate(
-      const BeginIterator                                            begin,
-      Iterator                                                       current,
-      const EndIterator                                              last,
-      [[maybe_unused]] const flags&                                  f,
-      R                                                              captures,
-      [[maybe_unused]] ctll::list<repeat<A, B, Content...>, Tail...> stack
+    const BeginIterator                                            begin,
+    Iterator                                                       current,
+    const EndIterator                                              last,
+    [[maybe_unused]] const flags&                                  f,
+    R                                                              captures,
+    [[maybe_unused]] ctll::list<repeat<A, B, Content...>, Tail...> stack
   ) {
     if constexpr ((B != 0) && (A > B)) {
       return not_matched;
     }
 #ifndef CTRE_DISABLE_GREEDY_OPT
-    else if constexpr (!collides(
-                           calculate_first(Content {}...),
-                           calculate_first(Tail {}...)
-                       )) {
+    else if constexpr (!collides(calculate_first(Content {}...), calculate_first(Tail {}...))) {
       return evaluate(
-          begin, current, last, f, captures,
-          ctll::list<possessive_repeat<A, B, Content...>, Tail...>()
+        begin,
+        current,
+        last,
+        f,
+        captures,
+        ctll::list<possessive_repeat<A, B, Content...>, Tail...>()
       );
     }
 #endif
     else {
       // A..B
-      size_t i {0};
+      size_t i { 0 };
       while (less_than<A>(i)) {
         auto inner_result = evaluate(
-            begin, current, last, not_empty_match(f), captures,
-            ctll::list<Content..., end_cycle_mark>()
+          begin,
+          current,
+          last,
+          not_empty_match(f),
+          captures,
+          ctll::list<Content..., end_cycle_mark>()
         );
 
-        if (!inner_result) return not_matched;
+        if (!inner_result)
+          return not_matched;
 
         captures = inner_result.unmatch();
         current  = inner_result.get_end_position();
@@ -8157,52 +7059,59 @@ namespace ctre {
 
   // capture (numeric ID)
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t Id,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t Id,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<capture<Id, Content...>, Tail...>) noexcept {
     return evaluate(
-        begin, current, last, f, captures.template start_capture<Id>(current),
-        ctll::list<sequence<Content...>, numeric_mark<Id>, Tail...>()
+      begin,
+      current,
+      last,
+      f,
+      captures.template start_capture<Id>(current),
+      ctll::list<sequence<Content...>, numeric_mark<Id>, Tail...>()
     );
   }
 
   // capture end mark (numeric and string ID)
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t Id,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t Id,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<numeric_mark<Id>, Tail...>) noexcept {
     return evaluate(
-        begin, current, last, f, captures.template end_capture<Id>(current),
-        ctll::list<Tail...>()
+      begin, current, last, f, captures.template end_capture<Id>(current), ctll::list<Tail...>()
     );
   }
 
   // capture (string ID)
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      size_t Id,
-      typename Name,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    size_t Id,
+    typename Name,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<capture_with_name<Id, Name, Content...>, Tail...>) noexcept {
     return evaluate(
-        begin, current, last, f, captures.template start_capture<Id>(current),
-        ctll::list<sequence<Content...>, numeric_mark<Id>, Tail...>()
+      begin,
+      current,
+      last,
+      f,
+      captures.template start_capture<Id>(current),
+      ctll::list<sequence<Content...>, numeric_mark<Id>, Tail...>()
     );
   }
 
@@ -8215,41 +7124,43 @@ namespace ctre {
 
   template <typename Iterator, typename EndIterator>
   constexpr CTRE_FORCE_INLINE string_match<Iterator> match_against_range(
-      Iterator          current,
-      const EndIterator last,
-      Iterator          range_current,
-      const Iterator    range_end,
-      flags
+    Iterator          current,
+    const EndIterator last,
+    Iterator          range_current,
+    const Iterator    range_end,
+    flags
   ) noexcept {
     while (last != current && range_end != range_current) {
       if (*current == *range_current) {
         current++;
         range_current++;
       } else {
-        return {current, false};
+        return { current, false };
       }
     }
-    return {current, range_current == range_end};
+    return { current, range_current == range_end };
   }
 
   // backreference with name
   template <
-      typename R,
-      typename Id,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename Id,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<back_reference_with_name<Id>, Tail...>) noexcept {
     if (const auto ref = captures.template get<Id>()) {
-      if (auto result =
-              match_against_range(current, last, ref.begin(), ref.end(), f);
+      if (auto result = match_against_range(current, last, ref.begin(), ref.end(), f);
           result.match) {
         return evaluate(
-            begin, result.position, last,
-            consumed_something(f, ref.begin() != ref.end()), captures,
-            ctll::list<Tail...>()
+          begin,
+          result.position,
+          last,
+          consumed_something(f, ref.begin() != ref.end()),
+          captures,
+          ctll::list<Tail...>()
         );
       }
     }
@@ -8258,22 +7169,24 @@ namespace ctre {
 
   // backreference
   template <
-      typename R,
-      size_t Id,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    size_t Id,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<back_reference<Id>, Tail...>) noexcept {
     if (const auto ref = captures.template get<Id>()) {
-      if (auto result =
-              match_against_range(current, last, ref.begin(), ref.end(), f);
+      if (auto result = match_against_range(current, last, ref.begin(), ref.end(), f);
           result.match) {
         return evaluate(
-            begin, result.position, last,
-            consumed_something(f, ref.begin() != ref.end()), captures,
-            ctll::list<Tail...>()
+          begin,
+          result.position,
+          last,
+          consumed_something(f, ref.begin() != ref.end()),
+          captures,
+          ctll::list<Tail...>()
         );
       }
     }
@@ -8282,11 +7195,11 @@ namespace ctre {
 
   // end of lookahead
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator, Iterator, const EndIterator, flags, R captures, ctll::list<end_lookahead_mark>) noexcept {
     // TODO check interaction with non-empty flag
@@ -8294,11 +7207,11 @@ namespace ctre {
   }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator, Iterator, const EndIterator, flags, R captures, ctll::list<end_lookbehind_mark>) noexcept {
     // TODO check interaction with non-empty flag
@@ -8307,17 +7220,16 @@ namespace ctre {
 
   // lookahead positive
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<lookahead_positive<Content...>, Tail...>) noexcept {
     if (auto lookahead_result = evaluate(
-            begin, current, last, f, captures,
-            ctll::list<sequence<Content...>, end_lookahead_mark>()
+          begin, current, last, f, captures, ctll::list<sequence<Content...>, end_lookahead_mark>()
         )) {
       captures = lookahead_result.unmatch();
       return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
@@ -8328,17 +7240,16 @@ namespace ctre {
 
   // lookahead negative
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<lookahead_negative<Content...>, Tail...>) noexcept {
     if (auto lookahead_result = evaluate(
-            begin, current, last, f, captures,
-            ctll::list<sequence<Content...>, end_lookahead_mark>()
+          begin, current, last, f, captures, ctll::list<sequence<Content...>, end_lookahead_mark>()
         )) {
       return not_matched;
     } else {
@@ -8347,35 +7258,31 @@ namespace ctre {
   }
 
   // lookbehind positive
-  constexpr bool is_at_least_bidirectional(std::input_iterator_tag) {
-    return false;
-  }
+  constexpr bool is_at_least_bidirectional(std::input_iterator_tag) { return false; }
 
-  constexpr bool is_at_least_bidirectional(std::bidirectional_iterator_tag) {
-    return true;
-  }
+  constexpr bool is_at_least_bidirectional(std::bidirectional_iterator_tag) { return true; }
 
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<lookbehind_positive<Content...>, Tail...>) noexcept {
     static_assert(
-        is_at_least_bidirectional(
-            typename std::iterator_traits<Iterator>::iterator_category {}
-        ),
-        "to use lookbehind you must provide bi-directional iterator"
+      is_at_least_bidirectional(typename std::iterator_traits<Iterator>::iterator_category {}),
+      "to use lookbehind you must provide bi-directional iterator"
     );
 
     if (auto lookbehind_result = evaluate(
-            std::make_reverse_iterator(last),
-            std::make_reverse_iterator(current),
-            std::make_reverse_iterator(begin), f, captures,
-            ctll::list<sequence<Content...>, end_lookbehind_mark>()
+          std::make_reverse_iterator(last),
+          std::make_reverse_iterator(current),
+          std::make_reverse_iterator(begin),
+          f,
+          captures,
+          ctll::list<sequence<Content...>, end_lookbehind_mark>()
         )) {
       captures = lookbehind_result.unmatch();
       return evaluate(begin, current, last, f, captures, ctll::list<Tail...>());
@@ -8386,26 +7293,26 @@ namespace ctre {
 
   // lookbehind negative
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<lookbehind_negative<Content...>, Tail...>) noexcept {
     static_assert(
-        is_at_least_bidirectional(
-            typename std::iterator_traits<Iterator>::iterator_category {}
-        ),
-        "to use negative lookbehind you must provide bi-directional iterator"
+      is_at_least_bidirectional(typename std::iterator_traits<Iterator>::iterator_category {}),
+      "to use negative lookbehind you must provide bi-directional iterator"
     );
 
     if (auto lookbehind_result = evaluate(
-            std::make_reverse_iterator(last),
-            std::make_reverse_iterator(current),
-            std::make_reverse_iterator(begin), f, captures,
-            ctll::list<sequence<Content...>, end_lookbehind_mark>()
+          std::make_reverse_iterator(last),
+          std::make_reverse_iterator(current),
+          std::make_reverse_iterator(begin),
+          f,
+          captures,
+          ctll::list<sequence<Content...>, end_lookbehind_mark>()
         )) {
       return not_matched;
     } else {
@@ -8418,33 +7325,30 @@ namespace ctre {
 
   // atomic_group<...> is just transformation to possessive_repeat<1,1,...>
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename... Content,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename... Content,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<atomic_group<Content...>, Tail...>) noexcept {
     return evaluate(
-        begin, current, last, f, captures,
-        ctll::list<possessive_repeat<1, 1, Content...>, Tail...> {}
+      begin, current, last, f, captures, ctll::list<possessive_repeat<1, 1, Content...>, Tail...> {}
     );
   }
 
   // switching modes
   template <
-      typename R,
-      typename BeginIterator,
-      typename Iterator,
-      typename EndIterator,
-      typename Mode,
-      typename... Tail>
+    typename R,
+    typename BeginIterator,
+    typename Iterator,
+    typename EndIterator,
+    typename Mode,
+    typename... Tail>
   constexpr CTRE_FORCE_INLINE R
   evaluate(const BeginIterator begin, Iterator current, const EndIterator last, const flags& f, R captures, ctll::list<mode_switch<Mode>, Tail...>) noexcept {
-    return evaluate(
-        begin, current, last, f + Mode {}, captures, ctll::list<Tail...>()
-    );
+    return evaluate(begin, current, last, f + Mode {}, captures, ctll::list<Tail...>());
   }
 
 } // namespace ctre
@@ -8471,16 +7375,15 @@ namespace ctre {
   };
 
   template <
-      typename BeginIterator,
-      typename EndIterator,
-      typename RE,
-      typename ResultIterator = BeginIterator>
+    typename BeginIterator,
+    typename EndIterator,
+    typename RE,
+    typename ResultIterator = BeginIterator>
   struct regex_iterator {
-    using value_type =
-        decltype(RE::template exec_with_result_iterator<ResultIterator>(
-            std::declval<BeginIterator>(),
-            std::declval<EndIterator>()
-        ));
+    using value_type        = decltype(RE::template exec_with_result_iterator<ResultIterator>(
+      std::declval<BeginIterator>(),
+      std::declval<EndIterator>()
+    ));
     using iterator_category = std::forward_iterator_tag;
     using pointer           = void;
     using reference         = const value_type&;
@@ -8491,28 +7394,22 @@ namespace ctre {
     EndIterator   end {};
     value_type    current_match {};
 
-    constexpr CTRE_FORCE_INLINE regex_iterator() noexcept = default;
-    constexpr CTRE_FORCE_INLINE regex_iterator(const regex_iterator&) noexcept =
-        default;
-    constexpr CTRE_FORCE_INLINE regex_iterator(regex_iterator&&) noexcept =
-        default;
+    constexpr CTRE_FORCE_INLINE regex_iterator() noexcept                      = default;
+    constexpr CTRE_FORCE_INLINE regex_iterator(const regex_iterator&) noexcept = default;
+    constexpr CTRE_FORCE_INLINE regex_iterator(regex_iterator&&) noexcept      = default;
 
-    constexpr CTRE_FORCE_INLINE
-    regex_iterator(BeginIterator begin, EndIterator last) noexcept
-        : orig_begin {begin},
-          current {begin},
-          end {last},
-          current_match {RE::template exec_with_result_iterator<ResultIterator>(
-              current,
-              last
-          )} {
-      if (current_match) { current = current_match.template get<0>().end(); }
+    constexpr CTRE_FORCE_INLINE regex_iterator(BeginIterator begin, EndIterator last) noexcept
+      : orig_begin { begin },
+        current { begin },
+        end { last },
+        current_match { RE::template exec_with_result_iterator<ResultIterator>(current, last) } {
+      if (current_match) {
+        current = current_match.template get<0>().end();
+      }
     }
 
-    constexpr CTRE_FORCE_INLINE regex_iterator&
-    operator=(const regex_iterator&) noexcept = default;
-    constexpr CTRE_FORCE_INLINE regex_iterator&
-    operator=(regex_iterator&&) noexcept = default;
+    constexpr CTRE_FORCE_INLINE regex_iterator& operator=(const regex_iterator&) noexcept = default;
+    constexpr CTRE_FORCE_INLINE regex_iterator& operator=(regex_iterator&&) noexcept      = default;
 
     constexpr CTRE_FORCE_INLINE const value_type& operator*() const noexcept {
       return current_match;
@@ -8523,11 +7420,12 @@ namespace ctre {
         return *this;
       }
 
-      current_match = RE::template exec_with_result_iterator<ResultIterator>(
-          orig_begin, current, end
-      );
+      current_match =
+        RE::template exec_with_result_iterator<ResultIterator>(orig_begin, current, end);
 
-      if (current_match) { current = current_match.template get<0>().end(); }
+      if (current_match) {
+        current = current_match.template get<0>().end();
+      }
       return *this;
     }
     constexpr CTRE_FORCE_INLINE regex_iterator operator++(int) noexcept {
@@ -8536,94 +7434,77 @@ namespace ctre {
       return previous;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator==(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current == right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator!=(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return !(left.current == right.current);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator<(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current < right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator>(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current > right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator<=(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current <= right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator>=(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current >= right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator==(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        regex_end_iterator
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      regex_end_iterator
     ) noexcept {
       return !bool(left.current_match);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator==(
-        regex_end_iterator,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      regex_end_iterator,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return !bool(right.current_match);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator!=(
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            left,
-        regex_end_iterator
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      regex_end_iterator
     ) noexcept {
       return bool(left.current_match);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator!=(
-        regex_end_iterator,
-        const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>&
-            right
+      regex_end_iterator,
+      const regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return bool(right.current_match);
     }
   };
 
   template <
-      typename BeginIterator,
-      typename EndIterator,
-      typename RE,
-      typename ResultIterator = BeginIterator>
+    typename BeginIterator,
+    typename EndIterator,
+    typename RE,
+    typename ResultIterator = BeginIterator>
   struct regex_split_iterator {
-    using value_type =
-        decltype(RE::template exec_with_result_iterator<ResultIterator>(
-            std::declval<BeginIterator>(),
-            std::declval<EndIterator>()
-        ));
+    using value_type        = decltype(RE::template exec_with_result_iterator<ResultIterator>(
+      std::declval<BeginIterator>(),
+      std::declval<EndIterator>()
+    ));
     using iterator_category = std::forward_iterator_tag;
     using pointer           = void;
     using reference         = const value_type&;
@@ -8633,7 +7514,7 @@ namespace ctre {
     BeginIterator current {};
     EndIterator   end {};
     value_type    current_match {};
-    bool          last_match {false};
+    bool          last_match { false };
 
     constexpr CTRE_FORCE_INLINE void modify_match() {
       auto tmp = current_match.template get<0>().end();
@@ -8651,20 +7532,15 @@ namespace ctre {
     }
 
     constexpr CTRE_FORCE_INLINE regex_split_iterator() noexcept = default;
-    constexpr CTRE_FORCE_INLINE
-    regex_split_iterator(const regex_split_iterator&) noexcept = default;
-    constexpr CTRE_FORCE_INLINE
-    regex_split_iterator(regex_split_iterator&&) noexcept = default;
+    constexpr CTRE_FORCE_INLINE regex_split_iterator(const regex_split_iterator&) noexcept =
+      default;
+    constexpr CTRE_FORCE_INLINE regex_split_iterator(regex_split_iterator&&) noexcept = default;
 
-    constexpr CTRE_FORCE_INLINE
-    regex_split_iterator(BeginIterator begin, EndIterator last) noexcept
-        : orig_begin {begin},
-          current {begin},
-          end {last},
-          current_match {RE::template exec_with_result_iterator<ResultIterator>(
-              current,
-              last
-          )} {
+    constexpr CTRE_FORCE_INLINE regex_split_iterator(BeginIterator begin, EndIterator last) noexcept
+      : orig_begin { begin },
+        current { begin },
+        end { last },
+        current_match { RE::template exec_with_result_iterator<ResultIterator>(current, last) } {
       if (current_match) {
         modify_match();
       } else {
@@ -8674,8 +7550,8 @@ namespace ctre {
 
     constexpr CTRE_FORCE_INLINE regex_split_iterator&
     operator=(const regex_split_iterator&) noexcept = default;
-    constexpr CTRE_FORCE_INLINE regex_split_iterator&
-    operator=(regex_split_iterator&&) noexcept = default;
+    constexpr CTRE_FORCE_INLINE regex_split_iterator& operator=(regex_split_iterator&&) noexcept =
+      default;
 
     constexpr CTRE_FORCE_INLINE const value_type& operator*() const noexcept {
       return current_match;
@@ -8686,9 +7562,8 @@ namespace ctre {
         return *this;
       }
 
-      current_match = RE::template exec_with_result_iterator<ResultIterator>(
-          orig_begin, current, end
-      );
+      current_match =
+        RE::template exec_with_result_iterator<ResultIterator>(orig_begin, current, end);
 
       if (current_match) {
         modify_match();
@@ -8703,126 +7578,62 @@ namespace ctre {
       return previous;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator==(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current == right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator!=(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return !(left.current == right.current);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator<(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current < right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator>(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current > right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator<=(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current <= right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator>=(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return left.current >= right.current;
     }
     friend constexpr CTRE_FORCE_INLINE bool operator==(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        regex_end_iterator
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      regex_end_iterator
     ) noexcept {
       return !bool(left.current_match);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator==(
-        regex_end_iterator,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      regex_end_iterator,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return !bool(right.current_match);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator!=(
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& left,
-        regex_end_iterator
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& left,
+      regex_end_iterator
     ) noexcept {
       return bool(left.current_match);
     }
     friend constexpr CTRE_FORCE_INLINE bool operator!=(
-        regex_end_iterator,
-        const regex_split_iterator<
-            BeginIterator,
-            EndIterator,
-            RE,
-            ResultIterator>& right
+      regex_end_iterator,
+      const regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>& right
     ) noexcept {
       return bool(right.current_match);
     }
@@ -8838,51 +7649,42 @@ namespace ctre {
   constexpr bool is_range = false;
 
   template <
-      typename BeginIterator,
-      typename EndIterator,
-      typename RE,
-      typename ResultIterator = BeginIterator>
+    typename BeginIterator,
+    typename EndIterator,
+    typename RE,
+    typename ResultIterator = BeginIterator>
   struct regex_range {
     BeginIterator _begin;
     EndIterator   _end;
 
-    constexpr CTRE_FORCE_INLINE
-    regex_range(BeginIterator begin, EndIterator end) noexcept
-        : _begin {begin}, _end {end} {}
+    constexpr CTRE_FORCE_INLINE regex_range(BeginIterator begin, EndIterator end) noexcept
+      : _begin { begin }, _end { end } {}
 
     constexpr CTRE_FORCE_INLINE auto begin() const noexcept {
-      return regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>(
-          _begin, _end
-      );
-    }
-    constexpr CTRE_FORCE_INLINE auto end() const noexcept {
-      return regex_end_iterator {};
+      return regex_iterator<BeginIterator, EndIterator, RE, ResultIterator>(_begin, _end);
     }
+    constexpr CTRE_FORCE_INLINE auto end() const noexcept { return regex_end_iterator {}; }
   };
 
   template <typename... Ts>
   constexpr bool is_range<regex_range<Ts...>> = true;
 
   template <
-      typename BeginIterator,
-      typename EndIterator,
-      typename RE,
-      typename ResultIterator = BeginIterator>
+    typename BeginIterator,
+    typename EndIterator,
+    typename RE,
+    typename ResultIterator = BeginIterator>
   struct regex_split_range {
     BeginIterator _begin;
     EndIterator   _end;
 
-    constexpr CTRE_FORCE_INLINE
-    regex_split_range(BeginIterator begin, EndIterator end) noexcept
-        : _begin {begin}, _end {end} {}
+    constexpr CTRE_FORCE_INLINE regex_split_range(BeginIterator begin, EndIterator end) noexcept
+      : _begin { begin }, _end { end } {}
 
     constexpr CTRE_FORCE_INLINE auto begin() const noexcept {
-      return regex_split_iterator<
-          BeginIterator, EndIterator, RE, ResultIterator>(_begin, _end);
-    }
-    constexpr CTRE_FORCE_INLINE auto end() const noexcept {
-      return regex_end_iterator {};
+      return regex_split_iterator<BeginIterator, EndIterator, RE, ResultIterator>(_begin, _end);
     }
+    constexpr CTRE_FORCE_INLINE auto end() const noexcept { return regex_end_iterator {}; }
   };
 
   template <typename... Ts>
@@ -8896,9 +7698,8 @@ namespace ctre {
     using last_type  = decltype(std::declval<Range>().end());
 
     struct iterator {
-      using value_type        = decltype(RE::exec(
-          std::declval<typename std::iterator_traits<first_type>::value_type>()
-      ));
+      using value_type =
+        decltype(RE::exec(std::declval<typename std::iterator_traits<first_type>::value_type>()));
       using iterator_category = std::forward_iterator_tag;
       using pointer           = void;
       using reference         = const value_type&;
@@ -8910,7 +7711,7 @@ namespace ctre {
 
       constexpr CTRE_FORCE_INLINE iterator() noexcept = default;
       constexpr CTRE_FORCE_INLINE iterator(first_type f, last_type l) noexcept
-          : first {f}, last {l}, current_result {find_first()} {}
+        : first { f }, last { l }, current_result { find_first() } {}
 
       constexpr CTRE_FORCE_INLINE value_type find_first() noexcept {
         while (first != last) {
@@ -8982,15 +7783,12 @@ namespace ctre {
     Range range {};
 
     constexpr CTRE_FORCE_INLINE multi_subject_range() noexcept = default;
-    constexpr CTRE_FORCE_INLINE multi_subject_range(Range r) noexcept
-        : range {r} {}
+    constexpr CTRE_FORCE_INLINE multi_subject_range(Range r) noexcept : range { r } {}
 
     constexpr CTRE_FORCE_INLINE auto begin() const noexcept {
-      return iterator {range.begin(), range.end()};
-    }
-    constexpr CTRE_FORCE_INLINE auto end() const noexcept {
-      return end_iterator {};
+      return iterator { range.begin(), range.end() };
     }
+    constexpr CTRE_FORCE_INLINE auto end() const noexcept { return end_iterator {}; }
   };
 
   // this is not regex range!
@@ -9003,18 +7801,14 @@ namespace ctre {
 namespace std::ranges {
 
   template <typename... Ts>
-  inline constexpr bool enable_borrowed_range<::ctre::regex_range<Ts...>> =
-      true;
+  inline constexpr bool enable_borrowed_range<::ctre::regex_range<Ts...>> = true;
   template <typename... Ts>
-  inline constexpr bool
-      enable_borrowed_range<::ctre::regex_split_range<Ts...>> = true;
+  inline constexpr bool enable_borrowed_range<::ctre::regex_split_range<Ts...>> = true;
   template <typename Range, typename RE>
-  inline constexpr bool
-      enable_borrowed_range<::ctre::multi_subject_range<Range, RE>> =
-          enable_borrowed_range<Range>;
+  inline constexpr bool enable_borrowed_range<::ctre::multi_subject_range<Range, RE>> =
+    enable_borrowed_range<Range>;
   template <typename Range, typename RE>
-  inline constexpr bool enable_view<::ctre::multi_subject_range<Range, RE>> =
-      true;
+  inline constexpr bool enable_view<::ctre::multi_subject_range<Range, RE>> = true;
 
 } // namespace std::ranges
 #endif
@@ -9049,40 +7843,32 @@ namespace ctre {
     operator==(const char* ptr, zero_terminated_string_end_iterator) noexcept {
       return *ptr == '\0';
     }
-    constexpr CTRE_FORCE_INLINE friend bool operator==(
-        const wchar_t* ptr,
-        zero_terminated_string_end_iterator
-    ) noexcept {
+    constexpr CTRE_FORCE_INLINE friend bool
+    operator==(const wchar_t* ptr, zero_terminated_string_end_iterator) noexcept {
       return *ptr == 0;
     }
     constexpr CTRE_FORCE_INLINE friend bool
     operator!=(const char* ptr, zero_terminated_string_end_iterator) noexcept {
       return *ptr != '\0';
     }
-    constexpr CTRE_FORCE_INLINE friend bool operator!=(
-        const wchar_t* ptr,
-        zero_terminated_string_end_iterator
-    ) noexcept {
+    constexpr CTRE_FORCE_INLINE friend bool
+    operator!=(const wchar_t* ptr, zero_terminated_string_end_iterator) noexcept {
       return *ptr != 0;
     }
     constexpr CTRE_FORCE_INLINE friend bool
     operator==(zero_terminated_string_end_iterator, const char* ptr) noexcept {
       return *ptr == '\0';
     }
-    constexpr CTRE_FORCE_INLINE friend bool operator==(
-        zero_terminated_string_end_iterator,
-        const wchar_t* ptr
-    ) noexcept {
+    constexpr CTRE_FORCE_INLINE friend bool
+    operator==(zero_terminated_string_end_iterator, const wchar_t* ptr) noexcept {
       return *ptr == 0;
     }
     constexpr CTRE_FORCE_INLINE friend bool
     operator!=(zero_terminated_string_end_iterator, const char* ptr) noexcept {
       return *ptr != '\0';
     }
-    constexpr CTRE_FORCE_INLINE friend bool operator!=(
-        zero_terminated_string_end_iterator,
-        const wchar_t* ptr
-    ) noexcept {
+    constexpr CTRE_FORCE_INLINE friend bool
+    operator!=(zero_terminated_string_end_iterator, const wchar_t* ptr) noexcept {
       return *ptr != 0;
     }
   };
@@ -9091,45 +7877,43 @@ namespace ctre {
   class RangeLikeType {
     template <typename Y>
     static auto test(Y*)
-        -> decltype(std::declval<const Y&>().begin(), std::declval<const Y&>().end(), std::true_type());
+      -> decltype(std::declval<const Y&>().begin(), std::declval<const Y&>().end(), std::true_type());
     template <typename>
     static auto test(...) -> std::false_type;
 
    public:
     static inline constexpr bool value =
-        decltype(test<std::remove_reference_t<std::remove_const_t<T>>>(nullptr)
-        )::value;
+      decltype(test<std::remove_reference_t<std::remove_const_t<T>>>(nullptr))::value;
   };
 
   struct match_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
-    constexpr CTRE_FORCE_INLINE static auto exec(
-        IteratorBegin orig_begin,
-        IteratorBegin begin,
-        IteratorEnd   end,
-        RE
-    ) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
+    constexpr CTRE_FORCE_INLINE static auto
+    exec(IteratorBegin orig_begin, IteratorBegin begin, IteratorEnd end, RE) noexcept {
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
 
       return evaluate(
-          orig_begin, begin, end, Modifier {},
-          return_type<result_iterator, RE> {},
-          ctll::list<start_mark, RE, assert_subject_end, end_mark, accept>()
+        orig_begin,
+        begin,
+        end,
+        Modifier {},
+        return_type<result_iterator, RE> {},
+        ctll::list<start_mark, RE, assert_subject_end, end_mark, accept>()
       );
     }
 
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
       return exec<Modifier, ResultIterator>(begin, begin, end, RE {});
@@ -9138,19 +7922,15 @@ namespace ctre {
 
   struct search_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
-    constexpr CTRE_FORCE_INLINE static auto exec(
-        IteratorBegin orig_begin,
-        IteratorBegin begin,
-        IteratorEnd   end,
-        RE
-    ) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
+    constexpr CTRE_FORCE_INLINE static auto
+    exec(IteratorBegin orig_begin, IteratorBegin begin, IteratorEnd end, RE) noexcept {
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
 
       constexpr bool fixed = starts_with_anchor(Modifier {}, ctll::list<RE> {});
 
@@ -9158,9 +7938,12 @@ namespace ctre {
 
       for (; end != it && !fixed; ++it) {
         if (auto out = evaluate(
-                orig_begin, it, end, Modifier {},
-                return_type<result_iterator, RE> {},
-                ctll::list<start_mark, RE, end_mark, accept>()
+              orig_begin,
+              it,
+              end,
+              Modifier {},
+              return_type<result_iterator, RE> {},
+              ctll::list<start_mark, RE, end_mark, accept>()
             )) {
           return out;
         }
@@ -9168,23 +7951,28 @@ namespace ctre {
 
       // in case the RE is empty or fixed
       auto out = evaluate(
-          orig_begin, it, end, Modifier {}, return_type<result_iterator, RE> {},
-          ctll::list<start_mark, RE, end_mark, accept>()
+        orig_begin,
+        it,
+        end,
+        Modifier {},
+        return_type<result_iterator, RE> {},
+        ctll::list<start_mark, RE, end_mark, accept>()
       );
 
       // ALERT: ugly hack
       // propagate end even if it didn't match (this is needed for split
       // function)
-      if (!out) out.set_end_mark(it);
+      if (!out)
+        out.set_end_mark(it);
       return out;
     }
 
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
       return exec<Modifier, ResultIterator>(begin, begin, end, RE {});
@@ -9193,32 +7981,31 @@ namespace ctre {
 
   struct starts_with_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
-    constexpr CTRE_FORCE_INLINE static auto exec(
-        IteratorBegin orig_begin,
-        IteratorBegin begin,
-        IteratorEnd   end,
-        RE
-    ) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
+    constexpr CTRE_FORCE_INLINE static auto
+    exec(IteratorBegin orig_begin, IteratorBegin begin, IteratorEnd end, RE) noexcept {
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
       return evaluate(
-          orig_begin, begin, end, Modifier {},
-          return_type<result_iterator, RE> {},
-          ctll::list<start_mark, RE, end_mark, accept>()
+        orig_begin,
+        begin,
+        end,
+        Modifier {},
+        return_type<result_iterator, RE> {},
+        ctll::list<start_mark, RE, end_mark, accept>()
       );
     }
 
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
       return exec<Modifier, ResultIterator>(begin, begin, end, RE {});
@@ -9228,86 +8015,73 @@ namespace ctre {
   // wrapper which calls search on input
   struct range_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
       using wrapped_regex = regular_expression<RE, search_method, Modifier>;
 
-      return regex_range<
-          IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(
-          begin, end
-      );
+      return regex_range<IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(begin, end);
     }
   };
 
   struct tokenize_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
-      using wrapped_regex =
-          regular_expression<RE, starts_with_method, Modifier>;
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      using wrapped_regex = regular_expression<RE, starts_with_method, Modifier>;
 
-      return regex_range<
-          IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(
-          begin, end
-      );
+      return regex_range<IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(begin, end);
     }
   };
 
   struct split_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
       using wrapped_regex = regular_expression<RE, search_method, Modifier>;
 
-      return regex_split_range<
-          IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(
-          begin, end
+      return regex_split_range<IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(
+        begin, end
       );
     }
   };
 
   struct iterator_method {
     template <
-        typename Modifier       = singleline,
-        typename ResultIterator = void,
-        typename RE,
-        typename IteratorBegin,
-        typename IteratorEnd>
+      typename Modifier       = singleline,
+      typename ResultIterator = void,
+      typename RE,
+      typename IteratorBegin,
+      typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec(IteratorBegin begin, IteratorEnd end, RE) noexcept {
-      using result_iterator = std::conditional_t<
-          std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
+      using result_iterator =
+        std::conditional_t<std::is_same_v<ResultIterator, void>, IteratorBegin, ResultIterator>;
       using wrapped_regex = regular_expression<RE, search_method, Modifier>;
 
-      return regex_iterator<
-          IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(
-          begin, end
-      );
-    }
-    constexpr CTRE_FORCE_INLINE static auto exec() noexcept {
-      return regex_end_iterator {};
+      return regex_iterator<IteratorBegin, IteratorEnd, wrapped_regex, result_iterator>(begin, end);
     }
+    constexpr CTRE_FORCE_INLINE static auto exec() noexcept { return regex_end_iterator {}; }
   };
 
   template <typename RE, typename Method, typename Modifier>
@@ -9315,77 +8089,54 @@ namespace ctre {
     constexpr CTRE_FORCE_INLINE regular_expression() noexcept {}
     constexpr CTRE_FORCE_INLINE regular_expression(RE) noexcept {}
 
-    template <
-        typename ResultIterator,
-        typename IteratorBegin,
-        typename IteratorEnd>
+    template <typename ResultIterator, typename IteratorBegin, typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto exec_with_result_iterator(
-        IteratorBegin orig_begin,
-        IteratorBegin begin,
-        IteratorEnd   end
+      IteratorBegin orig_begin,
+      IteratorBegin begin,
+      IteratorEnd   end
     ) noexcept {
-      return Method::template exec<Modifier, ResultIterator>(
-          orig_begin, begin, end, RE {}
-      );
+      return Method::template exec<Modifier, ResultIterator>(orig_begin, begin, end, RE {});
     }
-    template <
-        typename ResultIterator,
-        typename IteratorBegin,
-        typename IteratorEnd>
+    template <typename ResultIterator, typename IteratorBegin, typename IteratorEnd>
     constexpr CTRE_FORCE_INLINE static auto
     exec_with_result_iterator(IteratorBegin begin, IteratorEnd end) noexcept {
       return Method::template exec<Modifier, ResultIterator>(begin, end, RE {});
     }
     template <typename Range>
     constexpr CTRE_FORCE_INLINE static auto multi_exec(Range&& range) noexcept {
-      return multi_subject_range<Range, regular_expression> {
-          std::forward<Range>(range)
-      };
-    }
-    constexpr CTRE_FORCE_INLINE static auto exec() noexcept {
-      return Method::template exec();
+      return multi_subject_range<Range, regular_expression> { std::forward<Range>(range) };
     }
+    constexpr CTRE_FORCE_INLINE static auto exec() noexcept { return Method::template exec(); }
     template <typename IteratorBegin, typename IteratorEnd>
-    constexpr CTRE_FORCE_INLINE static auto
-    exec(IteratorBegin begin, IteratorEnd end) noexcept {
+    constexpr CTRE_FORCE_INLINE static auto exec(IteratorBegin begin, IteratorEnd end) noexcept {
       return Method::template exec<Modifier>(begin, end, RE {});
     }
     static constexpr CTRE_FORCE_INLINE auto exec(const char* s) noexcept {
-      return Method::template exec<Modifier>(
-          s, zero_terminated_string_end_iterator(), RE {}
-      );
+      return Method::template exec<Modifier>(s, zero_terminated_string_end_iterator(), RE {});
     }
     static constexpr CTRE_FORCE_INLINE auto exec(const wchar_t* s) noexcept {
-      return Method::template exec<Modifier>(
-          s, zero_terminated_string_end_iterator(), RE {}
-      );
+      return Method::template exec<Modifier>(s, zero_terminated_string_end_iterator(), RE {});
     }
     static constexpr CTRE_FORCE_INLINE auto exec(std::string_view sv) noexcept {
       return exec(sv.begin(), sv.end());
     }
-    static constexpr CTRE_FORCE_INLINE auto exec(std::wstring_view sv
-    ) noexcept {
+    static constexpr CTRE_FORCE_INLINE auto exec(std::wstring_view sv) noexcept {
       return exec(sv.begin(), sv.end());
     }
 #ifdef CTRE_ENABLE_UTF8_RANGE
-    static constexpr CTRE_FORCE_INLINE auto exec(std::u8string_view sv
-    ) noexcept {
+    static constexpr CTRE_FORCE_INLINE auto exec(std::u8string_view sv) noexcept {
       return exec_with_result_iterator<const char8_t*>(
-          utf8_range(sv).begin(), utf8_range(sv).end()
+        utf8_range(sv).begin(), utf8_range(sv).end()
       );
     }
 #endif
-    static constexpr CTRE_FORCE_INLINE auto exec(std::u16string_view sv
-    ) noexcept {
+    static constexpr CTRE_FORCE_INLINE auto exec(std::u16string_view sv) noexcept {
       return exec(sv.begin(), sv.end());
     }
-    static constexpr CTRE_FORCE_INLINE auto exec(std::u32string_view sv
-    ) noexcept {
+    static constexpr CTRE_FORCE_INLINE auto exec(std::u32string_view sv) noexcept {
       return exec(sv.begin(), sv.end());
     }
-    template <
-        typename Range,
-        typename = typename std::enable_if<RangeLikeType<Range>::value>::type>
+    template <typename Range, typename = typename std::enable_if<RangeLikeType<Range>::value>::type>
     static constexpr CTRE_FORCE_INLINE auto exec(Range&& range) noexcept {
       return exec(std::begin(range), std::end(range));
     }
@@ -9397,143 +8148,97 @@ namespace ctre {
     }
     // api for pattern matching
     template <typename... Args>
-    CTRE_FORCE_INLINE constexpr auto try_extract(Args&&... args
-    ) const noexcept {
+    CTRE_FORCE_INLINE constexpr auto try_extract(Args&&... args) const noexcept {
       return exec(std::forward<Args>(args)...);
     }
 
     // for compatibility with _ctre literal
     template <typename... Args>
     static constexpr CTRE_FORCE_INLINE auto match(Args&&... args) noexcept {
-      return regular_expression<RE, match_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+      return regular_expression<RE, match_method, singleline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
     static constexpr CTRE_FORCE_INLINE auto search(Args&&... args) noexcept {
-      return regular_expression<RE, search_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+      return regular_expression<RE, search_method, singleline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto starts_with(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, starts_with_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+    static constexpr CTRE_FORCE_INLINE auto starts_with(Args&&... args) noexcept {
+      return regular_expression<RE, starts_with_method, singleline>::exec(std::forward<Args>(args
+      )...);
     }
     template <typename... Args>
     static constexpr CTRE_FORCE_INLINE auto range(Args&&... args) noexcept {
-      return regular_expression<RE, range_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+      return regular_expression<RE, range_method, singleline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
     static constexpr CTRE_FORCE_INLINE auto split(Args&&... args) noexcept {
-      return regular_expression<RE, split_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+      return regular_expression<RE, split_method, singleline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
     static constexpr CTRE_FORCE_INLINE auto tokenize(Args&&... args) noexcept {
-      return regular_expression<RE, tokenize_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+      return regular_expression<RE, tokenize_method, singleline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
     static constexpr CTRE_FORCE_INLINE auto iterator(Args&&... args) noexcept {
-      return regular_expression<RE, iterator_method, singleline>::exec(
-          std::forward<Args>(args)...
-      );
+      return regular_expression<RE, iterator_method, singleline>::exec(std::forward<Args>(args)...);
     }
 
     template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_match(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, match_method, multiline>::exec(
-          std::forward<Args>(args)...
+    static constexpr CTRE_FORCE_INLINE auto multiline_match(Args&&... args) noexcept {
+      return regular_expression<RE, match_method, multiline>::exec(std::forward<Args>(args)...);
+    }
+    template <typename... Args>
+    static constexpr CTRE_FORCE_INLINE auto multiline_search(Args&&... args) noexcept {
+      return regular_expression<RE, search_method, multiline>::exec(std::forward<Args>(args)...);
+    }
+    template <typename... Args>
+    static constexpr CTRE_FORCE_INLINE auto multiline_starts_with(Args&&... args) noexcept {
+      return regular_expression<RE, starts_with_method, multiline>::exec(std::forward<Args>(args)...
       );
     }
     template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_search(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, search_method, multiline>::exec(
-          std::forward<Args>(args)...
-      );
+    static constexpr CTRE_FORCE_INLINE auto multiline_range(Args&&... args) noexcept {
+      return regular_expression<RE, range_method, multiline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_starts_with(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, starts_with_method, multiline>::exec(
-          std::forward<Args>(args)...
-      );
+    static constexpr CTRE_FORCE_INLINE auto multiline_split(Args&&... args) noexcept {
+      return regular_expression<RE, split_method, multiline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_range(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, range_method, multiline>::exec(
-          std::forward<Args>(args)...
-      );
+    static constexpr CTRE_FORCE_INLINE auto multiline_tokenize(Args&&... args) noexcept {
+      return regular_expression<RE, tokenize_method, multiline>::exec(std::forward<Args>(args)...);
     }
     template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_split(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, split_method, multiline>::exec(
-          std::forward<Args>(args)...
-      );
-    }
-    template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_tokenize(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, tokenize_method, multiline>::exec(
-          std::forward<Args>(args)...
-      );
-    }
-    template <typename... Args>
-    static constexpr CTRE_FORCE_INLINE auto multiline_iterator(Args&&... args
-    ) noexcept {
-      return regular_expression<RE, iterator_method, multiline>::exec(
-          std::forward<Args>(args)...
-      );
+    static constexpr CTRE_FORCE_INLINE auto multiline_iterator(Args&&... args) noexcept {
+      return regular_expression<RE, iterator_method, multiline>::exec(std::forward<Args>(args)...);
     }
   };
 
   // range style API support for tokenize/range/split operations
   template <typename Range, typename RE, typename Modifier>
-  constexpr auto operator|(
-      Range&&                                        range,
-      regular_expression<RE, range_method, Modifier> re
-  ) noexcept {
+  constexpr auto
+  operator|(Range&& range, regular_expression<RE, range_method, Modifier> re) noexcept {
     return re.exec(std::forward<Range>(range));
   }
 
   template <typename Range, typename RE, typename Modifier>
-  constexpr auto operator|(
-      Range&&                                           range,
-      regular_expression<RE, tokenize_method, Modifier> re
-  ) noexcept {
+  constexpr auto
+  operator|(Range&& range, regular_expression<RE, tokenize_method, Modifier> re) noexcept {
     return re.exec(std::forward<Range>(range));
   }
 
   template <typename Range, typename RE, typename Modifier>
-  constexpr auto operator|(
-      Range&&                                        range,
-      regular_expression<RE, split_method, Modifier> re
-  ) noexcept {
+  constexpr auto
+  operator|(Range&& range, regular_expression<RE, split_method, Modifier> re) noexcept {
     return re.exec(std::forward<Range>(range));
   }
 
   template <typename Range, typename RE, typename Modifier>
-  constexpr auto operator|(
-      Range&&                                           range,
-      regular_expression<RE, iterator_method, Modifier> re
-  ) noexcept = delete;
+  constexpr auto
+  operator|(Range&& range, regular_expression<RE, iterator_method, Modifier> re) noexcept = delete;
 
   template <typename Range, typename RE, typename Method, typename Modifier>
-  constexpr auto operator|(
-      Range&&                                  range,
-      regular_expression<RE, Method, Modifier> re
-  ) noexcept {
+  constexpr auto operator|(Range&& range, regular_expression<RE, Method, Modifier> re) noexcept {
     return re.multi_exec(std::forward<Range>(range));
   }
 
@@ -9557,67 +8262,65 @@ namespace ctre {
   template <CTRE_REGEX_TEMPLATE_COPY_TYPE input>
   struct regex_builder {
     static constexpr auto _input = input;
-    using result =
-        typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::
-            template output<pcre_context<>>;
+    using result = typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::template output<
+      pcre_context<>>;
 
-    static constexpr auto n =
-        result::is_correct ? ~static_cast<size_t>(0) : result::position;
+    static constexpr auto n = result::is_correct ? ~static_cast<size_t>(0) : result::position;
 
     static_assert(
-        result::is_correct && problem_at_position<n> {},
-        "Regular Expression contains syntax error."
+      result::is_correct && problem_at_position<n> {},
+      "Regular Expression contains syntax error."
     );
 
     using type = ctll::conditional<
-        result::is_correct,
-        decltype(ctll::front(typename result::output_type::stack_type())),
-        ctll::list<reject>>;
+      result::is_correct,
+      decltype(ctll::front(typename result::output_type::stack_type())),
+      ctll::list<reject>>;
   };
 
   // case-sensitive
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto match = regular_expression<
-      typename regex_builder<input>::type,
-      match_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    match_method,
+    ctll::list<singleline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto search = regular_expression<
-      typename regex_builder<input>::type,
-      search_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    search_method,
+    ctll::list<singleline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto starts_with = regular_expression<
-      typename regex_builder<input>::type,
-      starts_with_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    starts_with_method,
+    ctll::list<singleline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto range = regular_expression<
-      typename regex_builder<input>::type,
-      range_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    range_method,
+    ctll::list<singleline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto split = regular_expression<
-      typename regex_builder<input>::type,
-      split_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    split_method,
+    ctll::list<singleline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto tokenize = regular_expression<
-      typename regex_builder<input>::type,
-      tokenize_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    tokenize_method,
+    ctll::list<singleline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto iterator = regular_expression<
-      typename regex_builder<input>::type,
-      iterator_method,
-      ctll::list<singleline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    iterator_method,
+    ctll::list<singleline, Modifiers...>>();
 
   static constexpr inline auto sentinel = regex_end_iterator();
 
@@ -9625,45 +8328,45 @@ namespace ctre {
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_match = regular_expression<
-      typename regex_builder<input>::type,
-      match_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    match_method,
+    ctll::list<multiline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_search = regular_expression<
-      typename regex_builder<input>::type,
-      search_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    search_method,
+    ctll::list<multiline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_starts_with = regular_expression<
-      typename regex_builder<input>::type,
-      starts_with_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    starts_with_method,
+    ctll::list<multiline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_range = regular_expression<
-      typename regex_builder<input>::type,
-      range_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    range_method,
+    ctll::list<multiline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_split = regular_expression<
-      typename regex_builder<input>::type,
-      split_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    split_method,
+    ctll::list<multiline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_tokenize = regular_expression<
-      typename regex_builder<input>::type,
-      tokenize_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    tokenize_method,
+    ctll::list<multiline, Modifiers...>>();
 
   template <CTRE_REGEX_INPUT_TYPE input, typename... Modifiers>
   static constexpr inline auto multiline_iterator = regular_expression<
-      typename regex_builder<input>::type,
-      iterator_method,
-      ctll::list<multiline, Modifiers...>>();
+    typename regex_builder<input>::type,
+    iterator_method,
+    ctll::list<multiline, Modifiers...>>();
 
   static constexpr inline auto multiline_sentinel = regex_end_iterator();
 
@@ -9682,7 +8385,7 @@ namespace ctre {
 #if !CTRE_CNTTP_COMPILER_CHECK
   template <typename CharT, CharT... input>
   static inline constexpr auto _fixed_string_reference =
-      ctll::fixed_string<sizeof...(input)>({input...});
+    ctll::fixed_string<sizeof...(input)>({ input... });
 #endif
 
   namespace literals {
@@ -9734,9 +8437,8 @@ namespace ctre {
     CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre() noexcept {
       constexpr auto _input = input; // workaround for GCC 9 bug 88092
 #endif
-      using tmp =
-          typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::
-              template output<pcre_context<>>;
+      using tmp = typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::template output<
+        pcre_context<>>;
       static_assert(tmp(), "Regular Expression contains syntax error.");
       if constexpr (tmp()) {
         using re = decltype(front(typename tmp::output_type::stack_type()));
@@ -9749,8 +8451,7 @@ namespace ctre {
 // this will need to be fixed with C++20
 #if !CTRE_CNTTP_COMPILER_CHECK
     template <typename CharT, CharT... charpack>
-    CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre_id(
-    ) noexcept {
+    CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre_id() noexcept {
       return id<charpack...>();
     }
 #endif
@@ -9784,26 +8485,23 @@ namespace ctre {
     CTRE_FLATTEN constexpr inline auto operator""_ctre_gen() noexcept {
       constexpr auto _input = input; // workaround for GCC 9 bug 88092
 #endif
-      using tmp =
-          typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::
-              template output<pcre_context<>>;
+      using tmp = typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::template output<
+        pcre_context<>>;
       static_assert(tmp(), "Regular Expression contains syntax error.");
       return typename tmp::output_type::stack_type();
     }
 
 #if !CTRE_CNTTP_COMPILER_CHECK
     template <typename CharT, CharT... charpack>
-    CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre_syntax(
-    ) noexcept {
+    CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre_syntax() noexcept {
       constexpr auto& _input = _fixed_string_reference<CharT, charpack...>;
 #else
     template <ctll::fixed_string input>
-    CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre_syntax(
-    ) noexcept {
+    CTRE_FLATTEN constexpr CTRE_FORCE_INLINE auto operator""_ctre_syntax() noexcept {
       constexpr auto _input = input; // workaround for GCC 9 bug 88092
 #endif
-      return ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::
-          template correct_with<pcre_context<>>;
+      return ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::template correct_with<
+        pcre_context<>>;
     }
 
 #endif
@@ -9861,8 +8559,8 @@ namespace ctre {
     constexpr auto& _input = input;
 #endif
 
-    using tmp = typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::
-        template output<pcre_context<>>;
+    using tmp = typename ctll::parser<ctre::pcre, _input, ctre::pcre_actions>::template output<
+      pcre_context<>>;
     static_assert(tmp(), "Regular Expression contains syntax error.");
     using regex = decltype(front(typename tmp::output_type::stack_type()));
     return ctre::regular_expression<regex, Modifier, singleline>();
@@ -9876,16 +8574,14 @@ namespace ctre {
 #define CTRE_V2__CTRE__OPERATORS__HPP
 
 template <typename A, typename B>
-constexpr auto
-operator|(ctre::regular_expression<A>, ctre::regular_expression<B>)
-    -> ctre::regular_expression<ctre::select<A, B>> {
+constexpr auto operator|(ctre::regular_expression<A>, ctre::regular_expression<B>)
+  -> ctre::regular_expression<ctre::select<A, B>> {
   return {};
 }
 
 template <typename A, typename B>
-constexpr auto
-operator>>(ctre::regular_expression<A>, ctre::regular_expression<B>)
-    -> ctre::regular_expression<ctre::sequence<A, B>> {
+constexpr auto operator>>(ctre::regular_expression<A>, ctre::regular_expression<B>)
+  -> ctre::regular_expression<ctre::sequence<A, B>> {
   return {};
 }
 
diff --git a/include/rfl/AddStructName.hpp b/include/rfl/AddStructName.hpp
index 82112c5..a365607 100644
--- a/include/rfl/AddStructName.hpp
+++ b/include/rfl/AddStructName.hpp
@@ -17,13 +17,11 @@ namespace rfl {
     /// Adds the name of the struct as a new field.
     template <class StructType>
     static auto process(auto&& _view) {
-      using LiteralType = Literal<
-          internal::remove_namespaces<internal::get_type_name<StructType>()>()>;
+      using LiteralType =
+        Literal<internal::remove_namespaces<internal::get_type_name<StructType>()>()>;
       using FieldType          = Field<field_name_, LiteralType>;
       const auto add_new_field = [](auto&&... _fields) {
-        return make_named_tuple(
-            FieldType(LiteralType()), std::move(_fields)...
-        );
+        return make_named_tuple(FieldType(LiteralType()), std::move(_fields)...);
       };
       return std::apply(add_new_field, std::move(_view.fields()));
     }
diff --git a/include/rfl/AllOf.hpp b/include/rfl/AllOf.hpp
index 1281154..3c7ff6f 100644
--- a/include/rfl/AllOf.hpp
+++ b/include/rfl/AllOf.hpp
@@ -19,10 +19,9 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto types     = std::vector<ValidationType>(
-          {C::template to_schema<T>(), Cs::template to_schema<T>()...}
-      );
-      return ValidationType {ValidationType::AllOf {.types_ = types}};
+      const auto types =
+        std::vector<ValidationType>({ C::template to_schema<T>(), Cs::template to_schema<T>()... });
+      return ValidationType { ValidationType::AllOf { .types_ = types } };
     }
 
    private:
diff --git a/include/rfl/AnyOf.hpp b/include/rfl/AnyOf.hpp
index 5c5414c..ca9d222 100644
--- a/include/rfl/AnyOf.hpp
+++ b/include/rfl/AnyOf.hpp
@@ -21,18 +21,17 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto types     = std::vector<ValidationType>(
-          {C::template to_schema<T>(), Cs::template to_schema<T>()...}
-      );
-      return ValidationType {ValidationType::AnyOf {.types_ = types}};
+      const auto types =
+        std::vector<ValidationType>({ C::template to_schema<T>(), Cs::template to_schema<T>()... });
+      return ValidationType { ValidationType::AnyOf { .types_ = types } };
     }
 
    private:
     static Error make_error_message(const std::vector<Error>& _errors) {
       std::string msg =
-          "Expected at least one of the following validations to pass, but "
-          "none "
-          "of them did:";
+        "Expected at least one of the following validations to pass, but "
+        "none "
+        "of them did:";
       for (size_t i = 0; i < _errors.size(); ++i) {
         msg += "\n" + std::to_string(i + 1) + ") " + _errors.at(i).what();
       }
@@ -40,16 +39,13 @@ namespace rfl {
     }
 
     template <class T, class Head, class... Tail>
-    static rfl::Result<T>
-    validate_impl(const T& _value, std::vector<Error> _errors) {
+    static rfl::Result<T> validate_impl(const T& _value, std::vector<Error> _errors) {
       const auto handle_err = [&](Error&& _err) {
         _errors.push_back(std::forward<Error>(_err));
         if constexpr (sizeof...(Tail) == 0) {
           return make_error_message(_errors);
         } else {
-          return validate_impl<T, Tail...>(
-              _value, std::forward<std::vector<Error>>(_errors)
-          );
+          return validate_impl<T, Tail...>(_value, std::forward<std::vector<Error>>(_errors));
         }
       };
       return Head::validate(_value).or_else(handle_err);
diff --git a/include/rfl/Attribute.hpp b/include/rfl/Attribute.hpp
index 6d84f49..40ec2b8 100644
--- a/include/rfl/Attribute.hpp
+++ b/include/rfl/Attribute.hpp
@@ -33,29 +33,19 @@ namespace rfl {
     template <class U>
     Attribute(Attribute<U>&& _attr) : value_(_attr.get()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Attribute(const U& _value) : value_(_value) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Attribute(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Attribute(const Attribute<U>& _attr) : value_(_attr.value()) {}
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     Attribute(const Default& _default) : value_(Type()) {}
 
     ~Attribute() = default;
@@ -82,10 +72,7 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     auto& operator=(const U& _value) {
       value_ = _value;
       return *this;
@@ -93,9 +80,8 @@ namespace rfl {
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     auto& operator=(const Default& _default) {
       value_ = Type();
       return *this;
diff --git a/include/rfl/Box.hpp b/include/rfl/Box.hpp
index f9de560..e8aef11 100644
--- a/include/rfl/Box.hpp
+++ b/include/rfl/Box.hpp
@@ -38,8 +38,7 @@ namespace rfl {
     Box(Box<T>&& _other) = default;
 
     template <class U>
-    Box(Box<U>&& _other) noexcept
-        : ptr_(std::forward<std::unique_ptr<U>>(_other.ptr())) {}
+    Box(Box<U>&& _other) noexcept : ptr_(std::forward<std::unique_ptr<U>>(_other.ptr())) {}
 
     ~Box() = default;
 
@@ -110,9 +109,7 @@ namespace std {
 
   template <class T>
   struct hash<rfl::Box<T>> {
-    size_t operator()(const rfl::Box<T>& _b) const {
-      return hash<unique_ptr<T>>()(_b.ptr());
-    }
+    size_t operator()(const rfl::Box<T>& _b) const { return hash<unique_ptr<T>>()(_b.ptr()); }
   };
 
   template <class T>
diff --git a/include/rfl/Description.hpp b/include/rfl/Description.hpp
index d8350ff..086c9ed 100644
--- a/include/rfl/Description.hpp
+++ b/include/rfl/Description.hpp
@@ -36,36 +36,24 @@ namespace rfl {
     Description(const Description<_description, Type>& _field) = default;
 
     template <class U>
-    Description(const Description<_description, U>& _field)
-        : value_(_field.get()) {}
+    Description(const Description<_description, U>& _field) : value_(_field.get()) {}
 
     template <class U>
     Description(Description<_description, U>&& _field) : value_(_field.get()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Description(const U& _value) : value_(_value) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Description(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
-    Description(const Description<_description, U>& _field)
-        : value_(_field.value()) {}
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
+    Description(const Description<_description, U>& _field) : value_(_field.value()) {}
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     Description(const Default& _default) : value_(Type()) {}
 
     ~Description() = default;
@@ -95,10 +83,7 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     auto& operator=(const U& _value) {
       value_ = _value;
       return *this;
@@ -106,23 +91,18 @@ namespace rfl {
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     auto& operator=(const Default& _default) {
       value_ = Type();
       return *this;
     }
 
     /// Assigns the underlying object.
-    Description<_description, T>& operator=(
-        const Description<_description, T>& _field
-    ) = default;
+    Description<_description, T>& operator=(const Description<_description, T>& _field) = default;
 
     /// Assigns the underlying object.
-    Description<_description, T>& operator=(
-        Description<_description, T>&& _field
-    ) = default;
+    Description<_description, T>& operator=(Description<_description, T>&& _field) = default;
 
     /// Assigns the underlying object.
     template <class U>
diff --git a/include/rfl/Field.hpp b/include/rfl/Field.hpp
index 81b2cc3..c00357a 100644
--- a/include/rfl/Field.hpp
+++ b/include/rfl/Field.hpp
@@ -39,29 +39,19 @@ namespace rfl {
     template <class U>
     Field(Field<_name, U>&& _field) : value_(_field.get()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Field(const U& _value) : value_(_value) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Field(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Field(const Field<_name, U>& _field) : value_(_field.value()) {}
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     Field(const Default& _default) : value_(Type()) {}
 
     ~Field() = default;
@@ -94,10 +84,7 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     auto& operator=(const U& _value) {
       value_ = _value;
       return *this;
@@ -105,9 +92,8 @@ namespace rfl {
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     auto& operator=(const Default& _default) {
       value_ = Type();
       return *this;
diff --git a/include/rfl/Flatten.hpp b/include/rfl/Flatten.hpp
index ae83ff2..9d59c23 100644
--- a/include/rfl/Flatten.hpp
+++ b/include/rfl/Flatten.hpp
@@ -29,16 +29,10 @@ namespace rfl {
     template <class U>
     Flatten(Flatten<U>&& _f) : value_(_f.get()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Flatten(const U& _value) : value_(_value) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Flatten(U&& _value) : value_(_value) {}
 
     ~Flatten() = default;
@@ -68,10 +62,7 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Flatten<T>& operator=(const U& _value) {
       value_ = _value;
       return *this;
diff --git a/include/rfl/Literal.hpp b/include/rfl/Literal.hpp
index 2bc6070..de29a02 100644
--- a/include/rfl/Literal.hpp
+++ b/include/rfl/Literal.hpp
@@ -26,9 +26,9 @@ namespace rfl {
 
    public:
     using ValueType = std::conditional_t<
-        sizeof...(fields_) <= std::numeric_limits<std::uint8_t>::max(),
-        std::uint8_t,
-        std::uint16_t>;
+      sizeof...(fields_) <= std::numeric_limits<std::uint8_t>::max(),
+      std::uint8_t,
+      std::uint16_t>;
 
     /// The number of different fields or different options that the literal
     /// can assume.
@@ -46,9 +46,7 @@ namespace rfl {
 
     /// A single-field literal is special because it
     /// can also have a default constructor.
-    template <
-        ValueType num_fields = num_fields_,
-        typename             = std::enable_if_t<num_fields <= 1>>
+    template <ValueType num_fields = num_fields_, typename = std::enable_if_t<num_fields <= 1>>
     Literal() : value_(0) {}
 
     ~Literal() = default;
@@ -69,9 +67,7 @@ namespace rfl {
     /// Constructs a new Literal.
     template <ValueType _value>
     static Literal<fields_...> from_value() {
-      static_assert(
-          _value < num_fields_, "Value cannot exceed number of fields."
-      );
+      static_assert(_value < num_fields_, "Value cannot exceed number of fields.");
       return Literal<fields_...>(_value);
     }
 
@@ -132,9 +128,7 @@ namespace rfl {
     /// Constructs a Literal from a string. Returns an error if the string
     /// cannot be found.
     static Result<Literal> from_string(const std::string& _str) {
-      const auto to_literal = [](const auto& _v) {
-        return Literal<fields_...>(_v);
-      };
+      const auto to_literal = [](const auto& _v) { return Literal<fields_...>(_v); };
       return find_value(_str).transform(to_literal);
     };
 
@@ -156,8 +150,7 @@ namespace rfl {
     Literal<fields_...>& operator=(const Literal<fields_...>& _other) = default;
 
     /// Assigns from another literal.
-    Literal<fields_...>& operator=(Literal<fields_...>&& _other
-    ) noexcept = default;
+    Literal<fields_...>& operator=(Literal<fields_...>&& _other) noexcept = default;
 
     /// Assigns the literal from a string
     Literal<fields_...>& operator=(const std::string& _str) {
@@ -166,9 +159,7 @@ namespace rfl {
     }
 
     /// <=> for other Literals with the same fields.
-    auto operator<=>(const Literal<fields_...>& _other) const {
-      return value() <=> _other.value();
-    }
+    auto operator<=>(const Literal<fields_...>& _other) const { return value() <=> _other.value(); }
 
     /// <=> for other Literals with different fields.
     template <internal::StringLiteral... _fields>
@@ -177,9 +168,7 @@ namespace rfl {
     }
 
     /// <=> for strings.
-    inline auto operator<=>(const std::string& _str) const {
-      return name() <=> _str;
-    }
+    inline auto operator<=>(const std::string& _str) const { return name() <=> _str; }
 
     /// <=> for const char*.
     template <internal::StringLiteral... other_fields>
@@ -233,9 +222,7 @@ namespace rfl {
 
     /// Returns all of the allowed fields.
     template <int _i = 0>
-    static std::vector<std::string> allowed_strings_vec(
-        std::vector<std::string> _values = {}
-    ) {
+    static std::vector<std::string> allowed_strings_vec(std::vector<std::string> _values = {}) {
       using FieldType = typename std::tuple_element<_i, FieldsType>::type;
       const auto head = FieldType::field_.str();
       _values.push_back(head);
@@ -302,8 +289,8 @@ namespace rfl {
       }
       if constexpr (_i + 1 == num_fields_) {
         return Error(
-            "Literal does not support string '" + _str +
-            "'. The following strings are supported: " + allowed_strings() + "."
+          "Literal does not support string '" + _str +
+          "'. The following strings are supported: " + allowed_strings() + "."
         );
       } else {
         return find_value<_i + 1>(_str);
@@ -341,14 +328,11 @@ namespace rfl {
       }
     }
 
-    static_assert(
-        sizeof...(fields_) <= std::numeric_limits<ValueType>::max(),
-        "Too many fields."
-    );
+    static_assert(sizeof...(fields_) <= std::numeric_limits<ValueType>::max(), "Too many fields.");
 
     static_assert(
-        sizeof...(fields_) <= 1 || !has_duplicates(),
-        "Duplicate strings are not allowed in a Literal."
+      sizeof...(fields_) <= 1 || !has_duplicates(),
+      "Duplicate strings are not allowed in a Literal."
     );
 
    private:
diff --git a/include/rfl/MetaField.hpp b/include/rfl/MetaField.hpp
index 9f51db4..ae60ed0 100644
--- a/include/rfl/MetaField.hpp
+++ b/include/rfl/MetaField.hpp
@@ -8,8 +8,7 @@ namespace rfl {
   /// Contains meta-information about a field in a struct.
   class MetaField {
    public:
-    MetaField(const std::string& _name, const std::string& _type)
-        : name_(_name), type_(_type) {}
+    MetaField(const std::string& _name, const std::string& _type) : name_(_name), type_(_type) {}
 
     ~MetaField() = default;
 
diff --git a/include/rfl/NamedTuple.hpp b/include/rfl/NamedTuple.hpp
index bcd1a23..dc16638 100644
--- a/include/rfl/NamedTuple.hpp
+++ b/include/rfl/NamedTuple.hpp
@@ -31,64 +31,43 @@ namespace rfl {
    public:
     using Fields = std::tuple<std::remove_cvref_t<FieldTypes>...>;
     using Names  = Literal<std::remove_cvref_t<FieldTypes>::name_...>;
-    using Values =
-        std::tuple<typename std::remove_cvref_t<FieldTypes>::Type...>;
+    using Values = std::tuple<typename std::remove_cvref_t<FieldTypes>::Type...>;
 
    public:
     /// Construct from the values.
     NamedTuple(typename std::remove_cvref<FieldTypes>::type::Type&&... _values)
-        : values_(
-              std::forward<typename std::remove_cvref<FieldTypes>::type::Type>(
-                  _values
-              )...
-          ) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+      : values_(std::forward<typename std::remove_cvref<FieldTypes>::type::Type>(_values)...) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Construct from the values.
-    NamedTuple(
-        const typename std::remove_cvref<FieldTypes>::type::Type&... _values
-    )
-        : values_(std::make_tuple(_values...)) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+    NamedTuple(const typename std::remove_cvref<FieldTypes>::type::Type&... _values)
+      : values_(std::make_tuple(_values...)) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Construct from the fields.
-    NamedTuple(FieldTypes&&... _fields)
-        : values_(std::make_tuple(std::move(_fields.value_)...)) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+    NamedTuple(FieldTypes&&... _fields) : values_(std::make_tuple(std::move(_fields.value_)...)) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Construct from the fields.
-    NamedTuple(const FieldTypes&... _fields)
-        : values_(std::make_tuple(_fields.value_...)) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+    NamedTuple(const FieldTypes&... _fields) : values_(std::make_tuple(_fields.value_...)) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Construct from a tuple containing fields.
     NamedTuple(std::tuple<FieldTypes...>&& _tup)
-        : NamedTuple(std::make_from_tuple<NamedTuple<FieldTypes...>>(
-              std::forward<std::tuple<FieldTypes...>>(_tup)
-          )) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+      : NamedTuple(std::make_from_tuple<NamedTuple<FieldTypes...>>(
+          std::forward<std::tuple<FieldTypes...>>(_tup)
+        )) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Construct from a tuple containing fields.
     NamedTuple(const std::tuple<FieldTypes...>& _tup)
-        : NamedTuple(std::make_from_tuple<NamedTuple<FieldTypes...>>(_tup)) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+      : NamedTuple(std::make_from_tuple<NamedTuple<FieldTypes...>>(_tup)) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Copy constructor.
@@ -100,19 +79,15 @@ namespace rfl {
     /// Copy constructor.
     template <class... OtherFieldTypes>
     NamedTuple(const NamedTuple<OtherFieldTypes...>& _other)
-        : NamedTuple(retrieve_fields(_other.fields())) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+      : NamedTuple(retrieve_fields(_other.fields())) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     /// Move constructor.
     template <class... OtherFieldTypes>
     NamedTuple(NamedTuple<OtherFieldTypes...>&& _other)
-        : NamedTuple(retrieve_fields(_other.fields())) {
-      static_assert(
-          no_duplicate_field_names(), "Duplicate field names are not allowed"
-      );
+      : NamedTuple(retrieve_fields(_other.fields())) {
+      static_assert(no_duplicate_field_names(), "Duplicate field names are not allowed");
     }
 
     ~NamedTuple() = default;
@@ -123,12 +98,12 @@ namespace rfl {
       using Head = Field<_name, FType>;
       if constexpr (sizeof...(Tail) > 0) {
         return NamedTuple<FieldTypes..., std::remove_cvref_t<Head>>(
-                   make_fields<1, Head>(std::forward<Head>(_head))
+                 make_fields<1, Head>(std::forward<Head>(_head))
         )
-            .add(std::forward<Tail>(_tail)...);
+          .add(std::forward<Tail>(_tail)...);
       } else {
         return NamedTuple<FieldTypes..., std::remove_cvref_t<Head>>(
-            make_fields<1, Head>(std::forward<Head>(_head))
+          make_fields<1, Head>(std::forward<Head>(_head))
         );
       }
     }
@@ -138,14 +113,10 @@ namespace rfl {
     auto add(Field<_name, FType> _head, const Tail&... _tail) const {
       using Head = Field<_name, FType>;
       if constexpr (sizeof...(Tail) > 0) {
-        return NamedTuple<FieldTypes..., std::remove_cvref_t<Head>>(
-                   make_fields<1, Head>(_head)
-        )
-            .add(_tail...);
+        return NamedTuple<FieldTypes..., std::remove_cvref_t<Head>>(make_fields<1, Head>(_head))
+          .add(_tail...);
       } else {
-        return NamedTuple<FieldTypes..., std::remove_cvref_t<Head>>(
-            make_fields<1, Head>(_head)
-        );
+        return NamedTuple<FieldTypes..., std::remove_cvref_t<Head>>(make_fields<1, Head>(_head));
       }
     }
 
@@ -155,7 +126,7 @@ namespace rfl {
     auto add(std::tuple<TupContent...>&& _tuple, Tail&&... _tail) {
       if constexpr (sizeof...(Tail) > 0) {
         return add_tuple(std::forward<std::tuple<TupContent...>>(_tuple))
-            .add(std::forward<Tail>(_tail)...);
+          .add(std::forward<Tail>(_tail)...);
       } else {
         return add_tuple(std::forward<std::tuple<TupContent...>>(_tuple));
       }
@@ -177,16 +148,14 @@ namespace rfl {
     template <class... TupContent, class... Tail>
     auto add(NamedTuple<TupContent...>&& _named_tuple, Tail&&... _tail) {
       return add(
-          std::forward<std::tuple<TupContent...>>(_named_tuple.fields()),
-          std::forward<Tail>(_tail)...
+        std::forward<std::tuple<TupContent...>>(_named_tuple.fields()), std::forward<Tail>(_tail)...
       );
     }
 
     /// Template specialization for NamedTuple, so we can pass fields from other
     /// named tuples.
     template <class... TupContent, class... Tail>
-    auto add(NamedTuple<TupContent...> _named_tuple, const Tail&... _tail)
-        const {
+    auto add(NamedTuple<TupContent...> _named_tuple, const Tail&... _tail) const {
       return add(_named_tuple.fields(), _tail...);
     }
 
@@ -197,9 +166,10 @@ namespace rfl {
       const auto transform_field = [&_f](auto... _fields) {
         return std::tuple_cat(_f(std::move(_fields)).fields()...);
       };
-      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup
-                         ) { return NamedTuple<NewFields...>(_tup); };
-      auto       new_fields = std::apply(transform_field, std::move(fields()));
+      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup) {
+        return NamedTuple<NewFields...>(_tup);
+      };
+      auto new_fields = std::apply(transform_field, std::move(fields()));
       return to_nt(std::move(new_fields));
     }
 
@@ -210,17 +180,17 @@ namespace rfl {
       const auto transform_field = [&_f](auto... _fields) {
         return std::tuple_cat(_f(std::move(_fields)).fields()...);
       };
-      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup
-                         ) { return NamedTuple<NewFields...>(_tup); };
-      auto       new_fields = std::apply(transform_field, std::move(fields()));
+      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup) {
+        return NamedTuple<NewFields...>(_tup);
+      };
+      auto new_fields = std::apply(transform_field, std::move(fields()));
       return to_nt(std::move(new_fields));
     }
 
     /// Invokes a callable object once for each field in order.
     template <typename F>
     void apply(F&& _f) {
-      const auto apply_to_field = [&_f]<typename... AFields>(AFields&&... fields
-                                  ) {
+      const auto apply_to_field = [&_f]<typename... AFields>(AFields&&... fields) {
         ((_f(std::forward<AFields>(fields))), ...);
       };
       std::apply(apply_to_field, fields());
@@ -229,9 +199,7 @@ namespace rfl {
     /// Invokes a callable object once for each field in order.
     template <typename F>
     void apply(F&& _f) const {
-      const auto apply_to_field = [&_f](const auto&... fields) {
-        ((_f(fields)), ...);
-      };
+      const auto apply_to_field = [&_f](const auto&... fields) { ((_f(fields)), ...); };
       std::apply(apply_to_field, fields());
     }
 
@@ -284,12 +252,10 @@ namespace rfl {
     }
 
     /// Copy assignment operator.
-    NamedTuple<FieldTypes...>& operator=(const NamedTuple<FieldTypes...>& _other
-    ) = default;
+    NamedTuple<FieldTypes...>& operator=(const NamedTuple<FieldTypes...>& _other) = default;
 
     /// Move assignment operator.
-    NamedTuple<FieldTypes...>& operator=(NamedTuple<FieldTypes...>&& _other
-    ) noexcept = default;
+    NamedTuple<FieldTypes...>& operator=(NamedTuple<FieldTypes...>&& _other) noexcept = default;
 
     /// Equality operator
     inline auto operator==(const rfl::NamedTuple<FieldTypes...>& _other) const {
@@ -303,32 +269,27 @@ namespace rfl {
     /// Replaces one or several fields, returning a new version
     /// with the non-replaced fields left unchanged.
     template <internal::StringLiteral _name, class FType, class... OtherRFields>
-    auto
-    replace(Field<_name, FType>&& _field, OtherRFields&&... _other_fields) {
+    auto replace(Field<_name, FType>&& _field, OtherRFields&&... _other_fields) {
       using RField                    = Field<_name, FType>;
       constexpr auto num_other_fields = sizeof...(OtherRFields);
       if constexpr (num_other_fields == 0) {
         return replace_value<RField>(_field.value_);
       } else {
         return replace_value<RField>(_field.value_)
-            .replace(std::forward<OtherRFields>(_other_fields)...);
+          .replace(std::forward<OtherRFields>(_other_fields)...);
       }
     }
 
     /// Replaces one or several fields, returning a new version
     /// with the non-replaced fields left unchanged.
     template <internal::StringLiteral _name, class FType, class... OtherRFields>
-    auto replace(
-        Field<_name, FType> _field,
-        const OtherRFields&... _other_fields
-    ) const {
+    auto replace(Field<_name, FType> _field, const OtherRFields&... _other_fields) const {
       using RField                    = Field<_name, FType>;
       constexpr auto num_other_fields = sizeof...(OtherRFields);
       if constexpr (num_other_fields == 0) {
         return replace_value<RField>(std::move(_field.value_));
       } else {
-        return replace_value<RField>(std::move(_field.value_))
-            .replace(_other_fields...);
+        return replace_value<RField>(std::move(_field.value_)).replace(_other_fields...);
       }
     }
 
@@ -338,7 +299,7 @@ namespace rfl {
     auto replace(std::tuple<TupContent...>&& _tuple, Tail&&... _tail) {
       if constexpr (sizeof...(Tail) > 0) {
         return replace_tuple(std::forward<std::tuple<TupContent...>>(_tuple))
-            .replace(std::forward<Tail>(_tail)...);
+          .replace(std::forward<Tail>(_tail)...);
       } else {
         return replace_tuple(std::forward<std::tuple<TupContent...>>(_tuple));
       }
@@ -360,16 +321,14 @@ namespace rfl {
     template <class... TupContent, class... Tail>
     auto replace(NamedTuple<TupContent...>&& _named_tuple, Tail&&... _tail) {
       return replace(
-          std::forward<NamedTuple<TupContent...>>(_named_tuple).fields(),
-          std::forward<Tail>(_tail)...
+        std::forward<NamedTuple<TupContent...>>(_named_tuple).fields(), std::forward<Tail>(_tail)...
       );
     }
 
     /// Template specialization for NamedTuple, so we can pass fields from other
     /// named tuples.
     template <class... TupContent, class... Tail>
-    auto replace(NamedTuple<TupContent...> _named_tuple, const Tail&... _tail)
-        const {
+    auto replace(NamedTuple<TupContent...> _named_tuple, const Tail&... _tail) const {
       return replace(_named_tuple.fields(), _tail...);
     }
 
@@ -383,9 +342,10 @@ namespace rfl {
       const auto transform_field = [&_f](auto... fields) {
         return std::make_tuple(_f(std::move(fields))...);
       };
-      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup
-                         ) { return NamedTuple<NewFields...>(_tup); };
-      auto       new_fields = std::apply(transform_field, std::move(fields()));
+      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup) {
+        return NamedTuple<NewFields...>(_tup);
+      };
+      auto new_fields = std::apply(transform_field, std::move(fields()));
       return to_nt(std::move(new_fields));
     }
 
@@ -396,9 +356,10 @@ namespace rfl {
       const auto transform_field = [&_f](auto... fields) {
         return std::make_tuple(_f(std::move(fields))...);
       };
-      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup
-                         ) { return NamedTuple<NewFields...>(_tup); };
-      auto       new_fields = std::apply(transform_field, std::move(fields()));
+      const auto to_nt = []<class... NewFields>(std::tuple<NewFields...>&& _tup) {
+        return NamedTuple<NewFields...>(_tup);
+      };
+      auto new_fields = std::apply(transform_field, std::move(fields()));
       return to_nt(std::move(new_fields));
     }
 
@@ -446,8 +407,7 @@ namespace rfl {
         using FieldType = typename std::tuple_element<i, Fields>::type;
         using T         = std::remove_cvref_t<typename FieldType::Type>;
         return make_fields<num_additional_fields>(
-            FieldType(std::forward<T>(std::get<i>(values_))),
-            std::forward<Args>(_args)...
+          FieldType(std::forward<T>(std::get<i>(values_))), std::forward<Args>(_args)...
         );
       }
     }
@@ -468,7 +428,7 @@ namespace rfl {
         // them to the end, that is why we do it like this.
         using FieldType = typename std::tuple_element<i, Fields>::type;
         return make_fields<num_additional_fields>(
-            FieldType(std::get<i>(values_)), std::move(_args)...
+          FieldType(std::get<i>(values_)), std::move(_args)...
         );
       }
     }
@@ -487,18 +447,18 @@ namespace rfl {
 
         if constexpr (size == _index) {
           return make_replaced<_index, V, T>(
-              std::forward<V>(_values),
-              std::forward<T>(_val),
-              std::forward<Args>(_args)...,
-              FieldType(std::forward<T>(_val))
+            std::forward<V>(_values),
+            std::forward<T>(_val),
+            std::forward<Args>(_args)...,
+            FieldType(std::forward<T>(_val))
           );
         } else {
           using U = typename FieldType::Type;
           return make_replaced<_index, V, T>(
-              std::forward<V>(_values),
-              std::forward<T>(_val),
-              std::forward<Args>(_args)...,
-              FieldType(std::forward<U>(std::get<size>(_values)))
+            std::forward<V>(_values),
+            std::forward<T>(_val),
+            std::forward<Args>(_args)...,
+            FieldType(std::forward<U>(std::get<size>(_values)))
           );
         }
       }
@@ -514,9 +474,7 @@ namespace rfl {
     NamedTuple<FieldTypes...> replace_value(T&& _val) {
       using FieldType      = std::remove_cvref_t<Field>;
       constexpr auto index = internal::find_index<FieldType::name_, Fields>();
-      return make_replaced<index, Values, T>(
-          std::forward<Values>(values_), std::forward<T>(_val)
-      );
+      return make_replaced<index, Values, T>(std::forward<Values>(values_), std::forward<T>(_val));
     }
 
     /// Replaced the field signified by the field type.
@@ -525,9 +483,7 @@ namespace rfl {
       using FieldType       = std::remove_cvref_t<Field>;
       constexpr auto index  = internal::find_index<FieldType::name_, Fields>();
       auto           values = values_;
-      return make_replaced<index, Values, T>(
-          std::move(values), std::forward<T>(_val)
-      );
+      return make_replaced<index, Values, T>(std::move(values), std::forward<T>(_val));
     }
 
     /// Adds the elements of a tuple to a newly created named tuple,
@@ -552,10 +508,8 @@ namespace rfl {
 
     /// Retrieves the fields from another tuple.
     template <class... OtherFieldTypes, class... Args>
-    constexpr static Fields retrieve_fields(
-        std::tuple<OtherFieldTypes...>&& _other_fields,
-        Args&&... _args
-    ) {
+    constexpr static Fields
+    retrieve_fields(std::tuple<OtherFieldTypes...>&& _other_fields, Args&&... _args) {
       constexpr auto size = sizeof...(Args);
 
       constexpr bool retrieved_all_fields = size == std::tuple_size_v<Fields>;
@@ -563,20 +517,18 @@ namespace rfl {
       if constexpr (retrieved_all_fields) {
         return std::make_tuple(std::forward<Args>(_args)...);
       } else {
-        constexpr auto field_name =
-            std::tuple_element<size, Fields>::type::name_;
+        constexpr auto field_name = std::tuple_element<size, Fields>::type::name_;
 
-        constexpr auto index =
-            internal::find_index<field_name, std::tuple<OtherFieldTypes...>>();
+        constexpr auto index = internal::find_index<field_name, std::tuple<OtherFieldTypes...>>();
 
         using FieldType = typename std::tuple_element<size, Fields>::type;
 
         using T = std::remove_cvref_t<typename FieldType::Type>;
 
         return retrieve_fields(
-            std::forward<std::tuple<OtherFieldTypes...>>(_other_fields),
-            std::forward<Args>(_args)...,
-            FieldType(std::forward<T>(std::get<index>(_other_fields).value_))
+          std::forward<std::tuple<OtherFieldTypes...>>(_other_fields),
+          std::forward<Args>(_args)...,
+          FieldType(std::forward<T>(std::get<index>(_other_fields).value_))
         );
       }
     }
@@ -627,8 +579,7 @@ namespace rfl {
     /// Template specialization for NamedTuple, so we can pass fields from other
     /// named tuples.
     template <class... TupContent, class... Tail>
-    auto add(NamedTuple<TupContent...> _named_tuple, const Tail&... _tail)
-        const {
+    auto add(NamedTuple<TupContent...> _named_tuple, const Tail&... _tail) const {
       return add(_named_tuple.fields(), _tail...);
     }
 
@@ -661,72 +612,55 @@ namespace rfl {
   // ----------------------------------------------------------------------------
 
   template <
-      internal::StringLiteral _name1,
-      class Type1,
-      internal::StringLiteral _name2,
-      class Type2>
-  inline auto operator*(
-      const rfl::Field<_name1, Type1>& _f1,
-      const rfl::Field<_name2, Type2>& _f2
-  ) {
+    internal::StringLiteral _name1,
+    class Type1,
+    internal::StringLiteral _name2,
+    class Type2>
+  inline auto
+  operator*(const rfl::Field<_name1, Type1>& _f1, const rfl::Field<_name2, Type2>& _f2) {
     return NamedTuple(_f1, _f2);
   }
 
   template <internal::StringLiteral _name, class Type, class... FieldTypes>
-  inline auto operator*(
-      const NamedTuple<FieldTypes...>& _tup,
-      const rfl::Field<_name, Type>&   _f
-  ) {
+  inline auto operator*(const NamedTuple<FieldTypes...>& _tup, const rfl::Field<_name, Type>& _f) {
     return _tup.add(_f);
   }
 
   template <internal::StringLiteral _name, class Type, class... FieldTypes>
-  inline auto operator*(
-      const rfl::Field<_name, Type>&   _f,
-      const NamedTuple<FieldTypes...>& _tup
-  ) {
+  inline auto operator*(const rfl::Field<_name, Type>& _f, const NamedTuple<FieldTypes...>& _tup) {
     return NamedTuple(_f).add(_tup);
   }
 
   template <class... FieldTypes1, class... FieldTypes2>
-  inline auto operator*(
-      const NamedTuple<FieldTypes1...>& _tup1,
-      const NamedTuple<FieldTypes2...>& _tup2
-  ) {
+  inline auto
+  operator*(const NamedTuple<FieldTypes1...>& _tup1, const NamedTuple<FieldTypes2...>& _tup2) {
     return _tup1.add(_tup2);
   }
 
   template <
-      internal::StringLiteral _name1,
-      class Type1,
-      internal::StringLiteral _name2,
-      class Type2>
-  inline auto
-  operator*(rfl::Field<_name1, Type1>&& _f1, rfl::Field<_name2, Type2>&& _f2) {
+    internal::StringLiteral _name1,
+    class Type1,
+    internal::StringLiteral _name2,
+    class Type2>
+  inline auto operator*(rfl::Field<_name1, Type1>&& _f1, rfl::Field<_name2, Type2>&& _f2) {
     return NamedTuple(
-        std::forward<Field<_name1, Type1>>(_f1),
-        std::forward<Field<_name2, Type2>>(_f2)
+      std::forward<Field<_name1, Type1>>(_f1), std::forward<Field<_name2, Type2>>(_f2)
     );
   }
 
   template <internal::StringLiteral _name, class Type, class... FieldTypes>
-  inline auto
-  operator*(NamedTuple<FieldTypes...>&& _tup, rfl::Field<_name, Type>&& _f) {
+  inline auto operator*(NamedTuple<FieldTypes...>&& _tup, rfl::Field<_name, Type>&& _f) {
     return _tup.add(std::forward<Field<_name, Type>>(_f));
   }
 
   template <internal::StringLiteral _name, class Type, class... FieldTypes>
-  inline auto
-  operator*(rfl::Field<_name, Type>&& _f, NamedTuple<FieldTypes...>&& _tup) {
+  inline auto operator*(rfl::Field<_name, Type>&& _f, NamedTuple<FieldTypes...>&& _tup) {
     return NamedTuple(std::forward<Field<_name, Type>>(_f))
-        .add(std::forward<NamedTuple<FieldTypes...>>(_tup));
+      .add(std::forward<NamedTuple<FieldTypes...>>(_tup));
   }
 
   template <class... FieldTypes1, class... FieldTypes2>
-  inline auto operator*(
-      NamedTuple<FieldTypes1...>&& _tup1,
-      NamedTuple<FieldTypes2...>&& _tup2
-  ) {
+  inline auto operator*(NamedTuple<FieldTypes1...>&& _tup1, NamedTuple<FieldTypes2...>&& _tup2) {
     return _tup1.add(std::forward<NamedTuple<FieldTypes2...>>(_tup2));
   }
 
diff --git a/include/rfl/OneOf.hpp b/include/rfl/OneOf.hpp
index 9969e1e..66fd98e 100644
--- a/include/rfl/OneOf.hpp
+++ b/include/rfl/OneOf.hpp
@@ -21,16 +21,14 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto types     = std::vector<ValidationType>(
-          {C::template to_schema<T>(), Cs::template to_schema<T>()...}
-      );
-      return ValidationType {ValidationType::OneOf {.types_ = types}};
+      const auto types =
+        std::vector<ValidationType>({ C::template to_schema<T>(), Cs::template to_schema<T>()... });
+      return ValidationType { ValidationType::OneOf { .types_ = types } };
     }
 
    private:
     static Error make_error_message(const std::vector<Error>& _errors) {
-      std::string msg = "Expected exactly 1 out of " +
-                        std::to_string(sizeof...(Cs) + 1) +
+      std::string msg = "Expected exactly 1 out of " + std::to_string(sizeof...(Cs) + 1) +
                         " validations to pass, but " +
                         std::to_string(sizeof...(Cs) + 1 - _errors.size()) +
                         " of them did. The following errors were generated: ";
@@ -41,8 +39,7 @@ namespace rfl {
     }
 
     template <class T, class Head, class... Tail>
-    static rfl::Result<T>
-    validate_impl(const T& _value, std::vector<Error> _errors) {
+    static rfl::Result<T> validate_impl(const T& _value, std::vector<Error> _errors) {
       const auto push_back = [&](Error&& _err) -> rfl::Result<T> {
         _errors.emplace_back(std::forward<Error>(_err));
         return _err;
@@ -57,15 +54,11 @@ namespace rfl {
           }
           return make_error_message(_errors);
         } else {
-          return validate_impl<T, Tail...>(
-              _value, std::forward<std::vector<Error>>(_errors)
-          );
+          return validate_impl<T, Tail...>(_value, std::forward<std::vector<Error>>(_errors));
         }
       };
 
-      return Head::validate(_value)
-          .and_then(next_validation)
-          .or_else(next_validation);
+      return Head::validate(_value).and_then(next_validation).or_else(next_validation);
     }
   };
 
diff --git a/include/rfl/PatternValidator.hpp b/include/rfl/PatternValidator.hpp
index c163c90..a49052a 100644
--- a/include/rfl/PatternValidator.hpp
+++ b/include/rfl/PatternValidator.hpp
@@ -21,8 +21,8 @@ namespace rfl {
         return _str;
       } else {
         return rfl::Error(
-            "String '" + _str + "' did not match format '" + _name.str() +
-            "': '" + _regex.str() + "'."
+          "String '" + _str + "' did not match format '" + _name.str() + "': '" + _regex.str() +
+          "'."
         );
       }
     }
@@ -30,7 +30,7 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      return ValidationType {ValidationType::Regex {.pattern_ = Regex().str()}};
+      return ValidationType { ValidationType::Regex { .pattern_ = Regex().str() } };
     }
   };
 
diff --git a/include/rfl/Processors.hpp b/include/rfl/Processors.hpp
index dc6eb89..4a64a1c 100644
--- a/include/rfl/Processors.hpp
+++ b/include/rfl/Processors.hpp
@@ -22,14 +22,13 @@ namespace rfl {
 
   template <class Head, class... Tail>
   struct Processors<Head, Tail...> {
-    static constexpr bool all_required_ = std::disjunction_v<
-        internal::is_no_optionals<Head>,
-        internal::is_no_optionals<Tail>...>;
+    static constexpr bool all_required_ =
+      std::disjunction_v<internal::is_no_optionals<Head>, internal::is_no_optionals<Tail>...>;
 
     template <class T, class NamedTupleType>
     static auto process(NamedTupleType&& _named_tuple) {
       return Processors<Tail...>::template process<T>(
-          Head::template process<T>(std::move(_named_tuple))
+        Head::template process<T>(std::move(_named_tuple))
       );
     }
   };
diff --git a/include/rfl/Ref.hpp b/include/rfl/Ref.hpp
index b94d508..cc32493 100644
--- a/include/rfl/Ref.hpp
+++ b/include/rfl/Ref.hpp
@@ -50,8 +50,7 @@ namespace rfl {
     Ref(const Ref<U>& _other) : ptr_(_other.ptr()) {}
 
     template <class U>
-    Ref(Ref<U>&& _other) noexcept
-        : ptr_(std::forward<std::shared_ptr<U>>(_other.ptr())) {}
+    Ref(Ref<U>&& _other) noexcept : ptr_(std::forward<std::shared_ptr<U>>(_other.ptr())) {}
 
     ~Ref() = default;
 
@@ -132,9 +131,7 @@ namespace std {
 
   template <class T>
   struct hash<rfl::Ref<T>> {
-    size_t operator()(const rfl::Ref<T>& _r) const {
-      return hash<shared_ptr<T>>()(_r.ptr());
-    }
+    size_t operator()(const rfl::Ref<T>& _r) const { return hash<shared_ptr<T>>()(_r.ptr()); }
   };
 
   template <class T>
diff --git a/include/rfl/Rename.hpp b/include/rfl/Rename.hpp
index ffe9db7..6891d42 100644
--- a/include/rfl/Rename.hpp
+++ b/include/rfl/Rename.hpp
@@ -39,29 +39,19 @@ namespace rfl {
     template <class U>
     Rename(Rename<_name, U>&& _field) : value_(_field.get()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Rename(const U& _value) : value_(_value) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Rename(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Rename(const Rename<_name, U>& _field) : value_(_field.value()) {}
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     Rename(const Default& _default) : value_(Type()) {}
 
     ~Rename() = default;
@@ -91,10 +81,7 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     auto& operator=(const U& _value) {
       value_ = _value;
       return *this;
@@ -102,9 +89,8 @@ namespace rfl {
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     auto& operator=(const Default& _default) {
       value_ = Type();
       return *this;
diff --git a/include/rfl/Result.hpp b/include/rfl/Result.hpp
index 980ac4e..dc4e44a 100644
--- a/include/rfl/Result.hpp
+++ b/include/rfl/Result.hpp
@@ -40,52 +40,33 @@ namespace rfl {
   /// The Result class is used for monadic error handling.
   template <class T>
   class Result {
-    static_assert(
-        !std::is_same<T, Error>(),
-        "The result type cannot be Error."
-    );
+    static_assert(!std::is_same<T, Error>(), "The result type cannot be Error.");
 
-    using TOrErr =
-        std::array<unsigned char, std::max(sizeof(T), sizeof(Error))>;
+    using TOrErr = std::array<unsigned char, std::max(sizeof(T), sizeof(Error))>;
 
    public:
     using Type = T;
 
     Result(const T& _val) : success_(true) { new (&get_t()) T(_val); }
 
-    Result(T&& _val) noexcept : success_(true) {
-      new (&get_t()) T(std::move(_val));
-    }
+    Result(T&& _val) noexcept : success_(true) { new (&get_t()) T(std::move(_val)); }
 
-    Result(const Error& _err) : success_(false) {
-      new (&get_err()) Error(_err);
-    }
+    Result(const Error& _err) : success_(false) { new (&get_err()) Error(_err); }
 
-    Result(Error&& _err) noexcept : success_(false) {
-      new (&get_err()) Error(std::move(_err));
-    }
+    Result(Error&& _err) noexcept : success_(false) { new (&get_err()) Error(std::move(_err)); }
 
-    Result(Result<T>&& _other) noexcept : success_(_other.success_) {
-      move_from_other(_other);
-    }
+    Result(Result<T>&& _other) noexcept : success_(_other.success_) { move_from_other(_other); }
 
-    Result(const Result<T>& _other) : success_(_other.success_) {
-      copy_from_other(_other);
-    }
+    Result(const Result<T>& _other) : success_(_other.success_) { copy_from_other(_other); }
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
     Result(Result<U>&& _other) : success_(_other && true) {
-      auto temp = std::forward<Result<U>>(_other).transform([](U&& _u) {
-        return T(std::forward<U>(_u));
-      });
+      auto temp =
+        std::forward<Result<U>>(_other).transform([](U&& _u) { return T(std::forward<U>(_u)); });
       move_from_other(temp);
     }
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
     Result(const Result<U>& _other) : success_(_other && true) {
       auto temp = _other.transform([](const U& _u) { return T(_u); });
       move_from_other(temp);
@@ -209,9 +190,7 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
     auto& operator=(const Result<U>& _other) {
       const auto to_t = [](const U& _u) -> T { return _u; };
       t_or_err_       = _other.transform(to_t).t_or_err_;
@@ -320,8 +299,7 @@ namespace rfl {
 
     void destroy() {
       if (success_) {
-        if constexpr (std::is_destructible_v<
-                          T> /*&& !internal::is_array_v<T>*/) {
+        if constexpr (std::is_destructible_v<T> /*&& !internal::is_array_v<T>*/) {
           get_t().~T();
         }
       } else {
@@ -331,13 +309,9 @@ namespace rfl {
 
     T& get_t() noexcept { return *(reinterpret_cast<T*>(t_or_err_.data())); }
 
-    const T& get_t() const noexcept {
-      return *(reinterpret_cast<const T*>(t_or_err_.data()));
-    }
+    const T& get_t() const noexcept { return *(reinterpret_cast<const T*>(t_or_err_.data())); }
 
-    Error& get_err() noexcept {
-      return *(reinterpret_cast<Error*>(t_or_err_.data()));
-    }
+    Error& get_err() noexcept { return *(reinterpret_cast<Error*>(t_or_err_.data())); }
 
     const Error& get_err() const noexcept {
       return *(reinterpret_cast<const Error*>(t_or_err_.data()));
diff --git a/include/rfl/SnakeCaseToCamelCase.hpp b/include/rfl/SnakeCaseToCamelCase.hpp
index 4b3c5b5..d162bb0 100644
--- a/include/rfl/SnakeCaseToCamelCase.hpp
+++ b/include/rfl/SnakeCaseToCamelCase.hpp
@@ -26,10 +26,10 @@ namespace rfl {
     template <class FieldType>
     static auto handle_one_field(FieldType&& _f) {
       using NewFieldType = Field<
-          internal::transform_snake_case<
-              FieldType::name_,
-              /*capitalize=*/false>(),
-          typename FieldType::Type>;
+        internal::transform_snake_case<
+          FieldType::name_,
+          /*capitalize=*/false>(),
+        typename FieldType::Type>;
       return NewFieldType(_f.value());
     }
   };
diff --git a/include/rfl/SnakeCaseToPascalCase.hpp b/include/rfl/SnakeCaseToPascalCase.hpp
index f77a01b..58397e8 100644
--- a/include/rfl/SnakeCaseToPascalCase.hpp
+++ b/include/rfl/SnakeCaseToPascalCase.hpp
@@ -26,10 +26,10 @@ namespace rfl {
     template <class FieldType>
     static auto handle_one_field(FieldType&& _f) {
       using NewFieldType = Field<
-          internal::transform_snake_case<
-              FieldType::name_,
-              /*capitalize=*/true>(),
-          typename FieldType::Type>;
+        internal::transform_snake_case<
+          FieldType::name_,
+          /*capitalize=*/true>(),
+        typename FieldType::Type>;
       return NewFieldType(_f.value());
     }
   };
diff --git a/include/rfl/TaggedUnion.hpp b/include/rfl/TaggedUnion.hpp
index 959cfb5..55b8c85 100644
--- a/include/rfl/TaggedUnion.hpp
+++ b/include/rfl/TaggedUnion.hpp
@@ -19,30 +19,24 @@ namespace rfl {
     using VariantType = std::variant<Ts...>;
 
     /// A literal containing all the tags that are possible
-    using PossibleTags =
-        define_literal_t<internal::tag_t<_discriminator, Ts>...>;
+    using PossibleTags = define_literal_t<internal::tag_t<_discriminator, Ts>...>;
 
     TaggedUnion(const VariantType& _variant) : variant_(_variant) {}
 
-    TaggedUnion(VariantType&& _variant) noexcept
-        : variant_(std::move(_variant)) {}
+    TaggedUnion(VariantType&& _variant) noexcept : variant_(std::move(_variant)) {}
 
-    TaggedUnion(const TaggedUnion<_discriminator, Ts...>& _tagged_union
-    ) = default;
+    TaggedUnion(const TaggedUnion<_discriminator, Ts...>& _tagged_union) = default;
 
-    TaggedUnion(TaggedUnion<_discriminator, Ts...>&& _tagged_union
-    ) noexcept = default;
+    TaggedUnion(TaggedUnion<_discriminator, Ts...>&& _tagged_union) noexcept = default;
 
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     TaggedUnion(const T& _t) : variant_(_t) {}
 
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     TaggedUnion(T&& _t) noexcept : variant_(std::forward<T>(_t)) {}
 
     ~TaggedUnion() = default;
@@ -61,9 +55,8 @@ namespace rfl {
 
     /// Assigns the underlying object.
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     TaggedUnion<_discriminator, Ts...>& operator=(T&& _variant) {
       variant_ = std::forward<T>(_variant);
       return *this;
@@ -71,22 +64,19 @@ namespace rfl {
 
     /// Assigns the underlying object.
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     TaggedUnion<_discriminator, Ts...>& operator=(const T& _variant) {
       variant_ = _variant;
       return *this;
     }
 
     /// Assigns the underlying object.
-    TaggedUnion<_discriminator, Ts...>& operator=(
-        const TaggedUnion<_discriminator, Ts...>& _other
+    TaggedUnion<_discriminator, Ts...>& operator=(const TaggedUnion<_discriminator, Ts...>& _other
     ) = default;
 
     /// Assigns the underlying object.
-    TaggedUnion<_discriminator, Ts...>& operator=(
-        TaggedUnion<_discriminator, Ts...>&& _other
+    TaggedUnion<_discriminator, Ts...>& operator=(TaggedUnion<_discriminator, Ts...>&& _other
     ) = default;
 
     /// Returns the underlying variant.
@@ -96,8 +86,8 @@ namespace rfl {
     const VariantType& variant() const { return variant_; }
 
     static_assert(
-        !PossibleTags::has_duplicates(),
-        "Duplicate tags are not allowed inside tagged unions."
+      !PossibleTags::has_duplicates(),
+      "Duplicate tags are not allowed inside tagged unions."
     );
 
     /// The underlying variant - a TaggedUnion is a thin wrapper
@@ -112,58 +102,43 @@ namespace rfl {
      public:
       /// Retrieves the indicated value from the tuple.
       template <int _index>
-      static inline auto& get(
-          TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
-      ) {
-        return Getter<std::variant<NamedTupleTypes...>>::template get<_index>(
-            _tu.variant_
-        );
+      static inline auto& get(TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
+        return Getter<std::variant<NamedTupleTypes...>>::template get<_index>(_tu.variant_);
       }
 
       /// Gets a field by name.
       template <StringLiteral _field_name>
-      static inline auto& get(
-          TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
-      ) {
-        return Getter<std::variant<NamedTupleTypes...>>::template get<
-            _field_name>(_tu.variant_);
+      static inline auto& get(TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
+        return Getter<std::variant<NamedTupleTypes...>>::template get<_field_name>(_tu.variant_);
       }
 
       /// Gets a field by the field type.
       template <class Field>
-      static inline auto& get(
-          TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
-      ) {
-        return Getter<std::variant<NamedTupleTypes...>>::template get<Field>(
-            _tu.variant_
-        );
+      static inline auto& get(TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
+        return Getter<std::variant<NamedTupleTypes...>>::template get<Field>(_tu.variant_);
       }
 
       /// Retrieves the indicated value from the tuple.
       template <int _index>
-      static inline const auto& get_const(
-          const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
+      static inline const auto& get_const(const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
       ) {
-        return Getter<std::variant<NamedTupleTypes...>>::template get_const<
-            _index>(_tu.variant_);
+        return Getter<std::variant<NamedTupleTypes...>>::template get_const<_index>(_tu.variant_);
       }
 
       /// Gets a field by name.
       template <StringLiteral _field_name>
-      static inline const auto& get_const(
-          const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
+      static inline const auto& get_const(const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
       ) {
-        return Getter<std::variant<NamedTupleTypes...>>::template get_const<
-            _field_name>(_tu.variant_);
+        return Getter<std::variant<NamedTupleTypes...>>::template get_const<_field_name>(
+          _tu.variant_
+        );
       }
 
       /// Gets a field by the field type.
       template <class Field>
-      static inline const auto& get_const(
-          const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
+      static inline const auto& get_const(const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu
       ) {
-        return Getter<std::variant<NamedTupleTypes...>>::template get_const<
-            Field>(_tu.variant_);
+        return Getter<std::variant<NamedTupleTypes...>>::template get_const<Field>(_tu.variant_);
       }
     };
 
diff --git a/include/rfl/Timestamp.hpp b/include/rfl/Timestamp.hpp
index fba028f..3787ffd 100644
--- a/include/rfl/Timestamp.hpp
+++ b/include/rfl/Timestamp.hpp
@@ -29,8 +29,7 @@ namespace rfl {
       const auto r = strptime(_str, _format.str().c_str(), &tm_);
       if (r == NULL) {
         throw std::runtime_error(
-            "String '" + std::string(_str) + "' did not match format '" +
-            Format().str() + "'."
+          "String '" + std::string(_str) + "' did not match format '" + Format().str() + "'."
         );
       }
     }
diff --git a/include/rfl/Validator.hpp b/include/rfl/Validator.hpp
index a1752c7..bd0402a 100644
--- a/include/rfl/Validator.hpp
+++ b/include/rfl/Validator.hpp
@@ -21,8 +21,7 @@ namespace rfl {
   struct Validator {
    public:
     using ReflectionType = T;
-    using ValidationType =
-        std::conditional_t<sizeof...(Vs) == 0, V, AllOf<V, Vs...>>;
+    using ValidationType = std::conditional_t<sizeof...(Vs) == 0, V, AllOf<V, Vs...>>;
 
     /// Exception-free validation.
     static Result<Validator<T, V, Vs...>> from_value(const T& _value) noexcept {
@@ -39,21 +38,13 @@ namespace rfl {
 
     Validator(T&& _value) : value_(ValidationType::validate(_value).value()) {}
 
-    Validator(const T& _value)
-        : value_(ValidationType::validate(_value).value()) {}
+    Validator(const T& _value) : value_(ValidationType::validate(_value).value()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
-    Validator(U&& _value)
-        : value_(ValidationType::validate(T(std::forward<U>(_value))).value()) {
-    }
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    Validator(U&& _value) : value_(ValidationType::validate(T(std::forward<U>(_value))).value()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
-    Validator(const U& _value)
-        : value_(ValidationType::validate(T(_value)).value()) {}
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    Validator(const U& _value) : value_(ValidationType::validate(T(_value)).value()) {}
 
     ~Validator() = default;
 
@@ -70,26 +61,20 @@ namespace rfl {
     }
 
     /// Assigns the underlying object.
-    Validator<T, V, Vs...>& operator=(const Validator<T, V, Vs...>& _other
-    ) = default;
+    Validator<T, V, Vs...>& operator=(const Validator<T, V, Vs...>& _other) = default;
 
     /// Assigns the underlying object.
-    Validator<T, V, Vs...>& operator=(Validator<T, V, Vs...>&& _other
-    ) noexcept = default;
+    Validator<T, V, Vs...>& operator=(Validator<T, V, Vs...>&& _other) noexcept = default;
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
     auto& operator=(U&& _value) noexcept {
       value_ = ValidationType::validate(T(std::forward<U>(_value))).value();
       return *this;
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, T>, bool>::type = true>
     auto& operator=(const U& _value) {
       value_ = ValidationType::validate(T(_value)).value();
       return *this;
@@ -115,10 +100,7 @@ namespace rfl {
   };
 
   template <class T, class V, class... Vs>
-  inline auto operator<=>(
-      const Validator<T, V, Vs...>& _v1,
-      const Validator<T, V, Vs...>& _v2
-  ) {
+  inline auto operator<=>(const Validator<T, V, Vs...>& _v1, const Validator<T, V, Vs...>& _v2) {
     return _v1.value() <=> _v2.value();
   }
 
@@ -133,9 +115,7 @@ namespace std {
 
   template <class T, class V, class... Vs>
   struct hash<rfl::Validator<T, V, Vs...>> {
-    size_t operator()(const rfl::Validator<T, V, Vs...>& _v) const {
-      return hash<T>()(_v.value());
-    }
+    size_t operator()(const rfl::Validator<T, V, Vs...>& _v) const { return hash<T>()(_v.value()); }
   };
 
 } // namespace std
diff --git a/include/rfl/Variant.hpp b/include/rfl/Variant.hpp
index cdfb7dc..6ec2991 100644
--- a/include/rfl/Variant.hpp
+++ b/include/rfl/Variant.hpp
@@ -19,15 +19,13 @@ namespace rfl {
     Variant(Variant<AlternativeTypes...>&& _variant) noexcept = default;
 
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     Variant(const T& _t) : variant_(_t) {}
 
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     Variant(T&& _t) noexcept : variant_(std::forward<T>(_t)) {}
 
     ~Variant() = default;
@@ -46,9 +44,8 @@ namespace rfl {
 
     /// Assigns the underlying object.
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     Variant<AlternativeTypes...>& operator=(T&& _variant) {
       variant_ = std::forward<T>(_variant);
       return *this;
@@ -56,23 +53,18 @@ namespace rfl {
 
     /// Assigns the underlying object.
     template <
-        class T,
-        typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::
-            type = true>
+      class T,
+      typename std::enable_if<std::is_convertible_v<T, VariantType>, bool>::type = true>
     Variant<AlternativeTypes...>& operator=(const T& _variant) {
       variant_ = _variant;
       return *this;
     }
 
     /// Assigns the underlying object.
-    Variant<AlternativeTypes...>& operator=(
-        const Variant<AlternativeTypes...>& _other
-    ) = default;
+    Variant<AlternativeTypes...>& operator=(const Variant<AlternativeTypes...>& _other) = default;
 
     /// Assigns the underlying object.
-    Variant<AlternativeTypes...>& operator=(
-        Variant<AlternativeTypes...>&& _other
-    ) = default;
+    Variant<AlternativeTypes...>& operator=(Variant<AlternativeTypes...>&& _other) = default;
 
     /// Returns the underlying variant.
     VariantType& variant() { return variant_; }
diff --git a/include/rfl/as.hpp b/include/rfl/as.hpp
index 1213933..6ba4c85 100644
--- a/include/rfl/as.hpp
+++ b/include/rfl/as.hpp
@@ -14,8 +14,7 @@ namespace rfl {
       return from_named_tuple<T>(to_named_tuple(std::forward<Head>(_head)));
     } else {
       return from_named_tuple<T>(
-          to_named_tuple(std::forward<Head>(_head))
-              .add(to_named_tuple(std::forward<Tail>(_tail))...)
+        to_named_tuple(std::forward<Head>(_head)).add(to_named_tuple(std::forward<Tail>(_tail))...)
       );
     }
   }
@@ -26,8 +25,7 @@ namespace rfl {
     if constexpr (sizeof...(_tail) == 0) {
       return from_named_tuple<T>(to_named_tuple(_head));
     } else {
-      return from_named_tuple<T>(to_named_tuple(_head).add(to_named_tuple(_tail
-      )...));
+      return from_named_tuple<T>(to_named_tuple(_head).add(to_named_tuple(_tail)...));
     }
   }
 
diff --git a/include/rfl/bson/Parser.hpp b/include/rfl/bson/Parser.hpp
index fb4f656..271d3f5 100644
--- a/include/rfl/bson/Parser.hpp
+++ b/include/rfl/bson/Parser.hpp
@@ -19,25 +19,18 @@ namespace rfl::parsing {
 
     using ParentType = Parent<W>;
 
-    static Result<bson_oid_t>
-    read(const R& _r, const InputVarType& _var) noexcept {
+    static Result<bson_oid_t> read(const R& _r, const InputVarType& _var) noexcept {
       return _r.template to_basic_type<bson_oid_t>(_var);
     }
 
     template <class P>
-    static void
-    write(const W& _w, const bson_oid_t& _oid, const P& _parent) noexcept {
+    static void write(const W& _w, const bson_oid_t& _oid, const P& _parent) noexcept {
       ParentType::add_value(_w, _oid, _parent);
     }
 
-    static schema::Type to_schema(
-        std::map<std::string, schema::Type>* _definitions
-    ) {
-      static_assert(
-          rfl::always_false_v<R>,
-          "bson_oid_t cannot be expressed inside a JSON schema."
-      );
-      return schema::Type {schema::Type::String {}};
+    static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+      static_assert(rfl::always_false_v<R>, "bson_oid_t cannot be expressed inside a JSON schema.");
+      return schema::Type { schema::Type::String {} };
     }
   };
 
diff --git a/include/rfl/bson/Reader.hpp b/include/rfl/bson/Reader.hpp
index 3eebbb4..e15bc55 100644
--- a/include/rfl/bson/Reader.hpp
+++ b/include/rfl/bson/Reader.hpp
@@ -47,12 +47,10 @@ namespace rfl {
 
       template <class T>
       static constexpr bool has_custom_constructor =
-          (requires(InputVarType var) { T::from_bson_obj(var); });
+        (requires(InputVarType var) { T::from_bson_obj(var); });
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&     _name,
-          const InputObjectType& _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType& _obj)
+        const noexcept {
         bson_t      b;
         bson_iter_t iter;
         const auto  doc = _obj.val_->val_.value.v_doc;
@@ -86,9 +84,7 @@ namespace rfl {
               return std::string(value.v_symbol.symbol, value.v_symbol.len);
 
             default:
-              return rfl::Error(
-                  "Could not cast to string. The type must be UTF8 or symbol."
-              );
+              return rfl::Error("Could not cast to string. The type must be UTF8 or symbol.");
           }
         } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
           if (btype != BSON_TYPE_BOOL) {
@@ -112,12 +108,11 @@ namespace rfl {
 
             default:
               return rfl::Error(
-                  "Could not cast to numeric value. The type must be double, "
-                  "int32, int64 or date_time."
+                "Could not cast to numeric value. The type must be double, "
+                "int32, int64 or date_time."
               );
           }
-        } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>(
-                             )) {
+        } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
           if (btype != BSON_TYPE_OID) {
             return rfl::Error("Could not cast to OID.");
           }
@@ -127,20 +122,17 @@ namespace rfl {
         }
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputArrayType> to_array(const InputVarType& _var) const noexcept {
         const auto btype = _var.val_->val_.value_type;
         if (btype != BSON_TYPE_ARRAY && btype != BSON_TYPE_DOCUMENT) {
           return Error("Could not cast to an array.");
         }
-        return InputArrayType {_var.val_};
+        return InputArrayType { _var.val_ };
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         bson_t      b;
         bson_iter_t iter;
         const auto  doc = _arr.val_->val_.value.v_doc;
@@ -158,10 +150,8 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
         bson_t      b;
         bson_iter_t iter;
         const auto  doc = _obj.val_->val_.value.v_doc;
@@ -176,18 +166,16 @@ namespace rfl {
         return std::nullopt;
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputObjectType> to_object(const InputVarType& _var) const noexcept {
         const auto btype = _var.val_->val_.value_type;
         if (btype != BSON_TYPE_DOCUMENT) {
           return Error("Could not cast to a document.");
         }
-        return InputObjectType {_var.val_};
+        return InputObjectType { _var.val_ };
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType& _var) const noexcept {
         try {
           return T::from_bson_obj(_var);
         } catch (std::exception& e) { return rfl::Error(e.what()); }
@@ -206,7 +194,7 @@ namespace rfl {
         values_->vec_.emplace_back(rfl::Box<BSONValue>::make());
         auto* last_value = values_->vec_.back().get();
         bson_value_copy(bson_iter_value(_iter), &last_value->val_);
-        return InputVarType {last_value};
+        return InputVarType { last_value };
       }
 
      private:
diff --git a/include/rfl/bson/Writer.hpp b/include/rfl/bson/Writer.hpp
index f516879..dc65e0f 100644
--- a/include/rfl/bson/Writer.hpp
+++ b/include/rfl/bson/Writer.hpp
@@ -41,14 +41,13 @@ namespace rfl {
      public:
       struct BSONOutputArray {
         BSONOutputArray(bson_array_builder_t* _val, ParentType _parent)
-            : parent_(_parent), val_(_val) {}
+          : parent_(_parent), val_(_val) {}
         ParentType            parent_;
         bson_array_builder_t* val_;
       };
 
       struct BSONOutputObject {
-        BSONOutputObject(bson_t* _val, ParentType _parent)
-            : parent_(_parent), val_(_val) {}
+        BSONOutputObject(bson_t* _val, ParentType _parent) : parent_(_parent), val_(_val) {}
         ParentType parent_;
         bson_t*    val_;
       };
@@ -79,83 +78,61 @@ namespace rfl {
 
       template <class T>
       OutputVarType value_as_root(const T& _var) const noexcept {
-        static_assert(
-            rfl::always_false_v<T>,
-            "BSON only allows arrays or objects as its root."
-        );
+        static_assert(rfl::always_false_v<T>, "BSON only allows arrays or objects as its root.");
         return OutputVarType {};
       }
 
-      OutputArrayType add_array_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         bson_array_builder_t* val;
         bson_array_builder_append_array_builder_begin(_parent->val_, &val);
-        return OutputArrayType(val, IsArray {_parent->val_});
+        return OutputArrayType(val, IsArray { _parent->val_ });
       }
 
       OutputArrayType add_array_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         bson_array_builder_t* val;
         bson_append_array_builder_begin(
-            _parent->val_, _name.data(), static_cast<int>(_name.size()), &val
+          _parent->val_, _name.data(), static_cast<int>(_name.size()), &val
         );
-        return OutputArrayType(val, IsObject {_parent->val_});
+        return OutputArrayType(val, IsObject { _parent->val_ });
       }
 
-      OutputObjectType add_object_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         subdocs_->emplace_back(rfl::Box<BSONType>());
-        bson_array_builder_append_document_begin(
-            _parent->val_, &(subdocs_->back()->val_)
-        );
-        return OutputObjectType(
-            &subdocs_->back()->val_, IsArray {_parent->val_}
-        );
+        bson_array_builder_append_document_begin(_parent->val_, &(subdocs_->back()->val_));
+        return OutputObjectType(&subdocs_->back()->val_, IsArray { _parent->val_ });
       }
 
       OutputObjectType add_object_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         subdocs_->emplace_back(rfl::Box<BSONType>());
         bson_append_document_begin(
-            _parent->val_,
-            _name.data(),
-            static_cast<int>(_name.size()),
-            &(subdocs_->back()->val_)
-        );
-        return OutputObjectType(
-            &subdocs_->back()->val_, IsObject {_parent->val_}
+          _parent->val_, _name.data(), static_cast<int>(_name.size()), &(subdocs_->back()->val_)
         );
+        return OutputObjectType(&subdocs_->back()->val_, IsObject { _parent->val_ });
       }
 
       template <class T>
-      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-          const noexcept {
+      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
         if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
           bson_array_builder_append_utf8(
-              _parent->val_, _var.c_str(), static_cast<int>(_var.size())
+            _parent->val_, _var.c_str(), static_cast<int>(_var.size())
           );
         } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
           bson_array_builder_append_bool(_parent->val_, _var);
         } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
-          bson_array_builder_append_double(
-              _parent->val_, static_cast<double>(_var)
-          );
+          bson_array_builder_append_double(_parent->val_, static_cast<double>(_var));
         } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
-          bson_array_builder_append_int64(
-              _parent->val_, static_cast<std::int64_t>(_var)
-          );
-        } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>(
-                             )) {
+          bson_array_builder_append_int64(_parent->val_, static_cast<std::int64_t>(_var));
+        } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
           bson_array_builder_append_oid(_parent->val_, &_var);
         } else {
           static_assert(rfl::always_false_v<T>, "Unsupported type.");
@@ -165,41 +142,33 @@ namespace rfl {
 
       template <class T>
       OutputVarType add_value_to_object(
-          const std::string_view& _name,
-          const T&                _var,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const T&                _var,
+        OutputObjectType*       _parent
       ) const noexcept {
         if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
           bson_append_utf8(
-              _parent->val_,
-              _name.data(),
-              static_cast<int>(_name.size()),
-              _var.c_str(),
-              static_cast<int>(_var.size())
+            _parent->val_,
+            _name.data(),
+            static_cast<int>(_name.size()),
+            _var.c_str(),
+            static_cast<int>(_var.size())
           );
         } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
-          bson_append_bool(
-              _parent->val_, _name.data(), static_cast<int>(_name.size()), _var
-          );
+          bson_append_bool(_parent->val_, _name.data(), static_cast<int>(_name.size()), _var);
         } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
           bson_append_double(
-              _parent->val_,
-              _name.data(),
-              static_cast<int>(_name.size()),
-              static_cast<double>(_var)
+            _parent->val_, _name.data(), static_cast<int>(_name.size()), static_cast<double>(_var)
           );
         } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
           bson_append_int64(
-              _parent->val_,
-              _name.data(),
-              static_cast<int>(_name.size()),
-              static_cast<std::int64_t>(_var)
-          );
-        } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>(
-                             )) {
-          bson_append_oid(
-              _parent->val_, _name.data(), static_cast<int>(_name.size()), &_var
+            _parent->val_,
+            _name.data(),
+            static_cast<int>(_name.size()),
+            static_cast<std::int64_t>(_var)
           );
+        } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
+          bson_append_oid(_parent->val_, _name.data(), static_cast<int>(_name.size()), &_var);
         } else {
           static_assert(rfl::always_false_v<T>, "Unsupported type.");
         }
@@ -211,13 +180,9 @@ namespace rfl {
         return OutputVarType {};
       }
 
-      OutputVarType add_null_to_object(
-          const std::string_view& _name,
-          OutputObjectType*       _parent
-      ) const noexcept {
-        bson_append_null(
-            _parent->val_, _name.data(), static_cast<int>(_name.size())
-        );
+      OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+        const noexcept {
+        bson_append_null(_parent->val_, _name.data(), static_cast<int>(_name.size()));
         return OutputVarType {};
       }
 
@@ -225,9 +190,7 @@ namespace rfl {
         const auto handle = [&](const auto _parent) {
           using Type = std::remove_cvref_t<decltype(_parent)>;
           if constexpr (std::is_same<Type, IsArray>()) {
-            bson_array_builder_append_array_builder_end(
-                _parent.ptr_, _arr->val_
-            );
+            bson_array_builder_append_array_builder_end(_parent.ptr_, _arr->val_);
           } else if constexpr (std::is_same<Type, IsObject>()) {
             bson_append_array_builder_end(_parent.ptr_, _arr->val_);
           } else if constexpr (std::is_same<Type, IsRoot>()) {
diff --git a/include/rfl/bson/load.hpp b/include/rfl/bson/load.hpp
index 2391e87..5715b00 100644
--- a/include/rfl/bson/load.hpp
+++ b/include/rfl/bson/load.hpp
@@ -10,9 +10,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_bytes = [](const auto& _bytes) {
-        return read<T, Ps...>(_bytes);
-      };
+      const auto read_bytes = [](const auto& _bytes) { return read<T, Ps...>(_bytes); };
       return rfl::io::load_bytes(_fname).and_then(read_bytes);
     }
 
diff --git a/include/rfl/bson/read.hpp b/include/rfl/bson/read.hpp
index ff1f2c4..bbd473a 100644
--- a/include/rfl/bson/read.hpp
+++ b/include/rfl/bson/read.hpp
@@ -30,7 +30,7 @@ namespace rfl {
       value.val_.value.v_doc.data_len = static_cast<uint32_t>(_size);
       value.val_.value.v_doc.data     = const_cast<uint8_t*>(_bytes);
       value.val_.value_type           = BSON_TYPE_DOCUMENT;
-      auto doc                        = InputVarType {&value};
+      auto doc                        = InputVarType { &value };
       return read<T, Ps...>(doc);
     }
 
diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp
index 098c6a6..6554e03 100644
--- a/include/rfl/bson/write.hpp
+++ b/include/rfl/bson/write.hpp
@@ -18,18 +18,15 @@ namespace rfl {
     /// call bson_free on the returned pointer.
     template <class... Ps>
     std::pair<uint8_t*, size_t> to_buffer(const auto& _obj) noexcept {
-      using T               = std::remove_cvref_t<decltype(_obj)>;
-      using ParentType      = parsing::Parent<Writer>;
-      bson_t*        doc    = nullptr;
-      uint8_t*       buf    = nullptr;
-      size_t         buflen = 0;
-      bson_writer_t* bson_writer =
-          bson_writer_new(&buf, &buflen, 0, bson_realloc_ctx, NULL);
+      using T                    = std::remove_cvref_t<decltype(_obj)>;
+      using ParentType           = parsing::Parent<Writer>;
+      bson_t*        doc         = nullptr;
+      uint8_t*       buf         = nullptr;
+      size_t         buflen      = 0;
+      bson_writer_t* bson_writer = bson_writer_new(&buf, &buflen, 0, bson_realloc_ctx, NULL);
       bson_writer_begin(bson_writer, &doc);
       const auto rfl_writer = Writer(doc);
-      Parser<T, Processors<Ps...>>::write(
-          rfl_writer, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(rfl_writer, _obj, typename ParentType::Root {});
       bson_writer_end(bson_writer);
       const auto len = bson_writer_get_length(bson_writer);
       bson_writer_destroy(bson_writer);
@@ -39,10 +36,9 @@ namespace rfl {
     /// Returns BSON bytes.
     template <class... Ps>
     std::vector<char> write(const auto& _obj) noexcept {
-      auto [buf, len]   = to_buffer<Ps...>(_obj);
-      const auto result = std::vector<char>(
-          reinterpret_cast<char*>(buf), reinterpret_cast<char*>(buf) + len
-      );
+      auto [buf, len] = to_buffer<Ps...>(_obj);
+      const auto result =
+        std::vector<char>(reinterpret_cast<char*>(buf), reinterpret_cast<char*>(buf) + len);
       bson_free(buf);
       return result;
     }
diff --git a/include/rfl/cbor/Parser.hpp b/include/rfl/cbor/Parser.hpp
index d108f6a..94b4e8b 100644
--- a/include/rfl/cbor/Parser.hpp
+++ b/include/rfl/cbor/Parser.hpp
@@ -12,33 +12,26 @@ namespace rfl {
     /// Because of that, we require all of the fields and then set them to
     /// nullptr, if necessary.
     template <class ProcessorsType, class... FieldTypes>
-      requires AreReaderAndWriter<
+      requires AreReaderAndWriter<cbor::Reader, cbor::Writer, NamedTuple<FieldTypes...>>
+    struct Parser<cbor::Reader, cbor::Writer, NamedTuple<FieldTypes...>, ProcessorsType>
+      : public NamedTupleParser<
           cbor::Reader,
           cbor::Writer,
-          NamedTuple<FieldTypes...>>
-    struct Parser<
-        cbor::Reader,
-        cbor::Writer,
-        NamedTuple<FieldTypes...>,
-        ProcessorsType>
-        : public NamedTupleParser<
-              cbor::Reader,
-              cbor::Writer,
-              /*_ignore_empty_containers=*/false,
-              /*_all_required=*/true,
-              ProcessorsType,
-              FieldTypes...> {};
+          /*_ignore_empty_containers=*/false,
+          /*_all_required=*/true,
+          ProcessorsType,
+          FieldTypes...> {};
 
     template <class ProcessorsType, class... Ts>
       requires AreReaderAndWriter<cbor::Reader, cbor::Writer, std::tuple<Ts...>>
     struct Parser<cbor::Reader, cbor::Writer, std::tuple<Ts...>, ProcessorsType>
-        : public TupleParser<
-              cbor::Reader,
-              cbor::Writer,
-              /*_ignore_empty_containers=*/false,
-              /*_all_required=*/true,
-              ProcessorsType,
-              Ts...> {};
+      : public TupleParser<
+          cbor::Reader,
+          cbor::Writer,
+          /*_ignore_empty_containers=*/false,
+          /*_all_required=*/true,
+          ProcessorsType,
+          Ts...> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/cbor/Reader.hpp b/include/rfl/cbor/Reader.hpp
index 2ce6b84..b06210e 100644
--- a/include/rfl/cbor/Reader.hpp
+++ b/include/rfl/cbor/Reader.hpp
@@ -43,12 +43,10 @@ namespace rfl {
 
       template <class T>
       static constexpr bool has_custom_constructor =
-          (requires(InputVarType var) { T::from_cbor_obj(var); });
+        (requires(InputVarType var) { T::from_cbor_obj(var); });
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&     _name,
-          const InputObjectType& _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType& _obj)
+        const noexcept {
         CborValue val;
         auto      buffer = std::vector<char>();
         auto      err    = cbor_value_enter_container(_obj.val_, &val);
@@ -134,9 +132,9 @@ namespace rfl {
             return static_cast<T>(result);
           }
           return rfl::Error(
-              "Could not cast to numeric value. The type must be integral, "
-              "float "
-              "or double."
+            "Could not cast to numeric value. The type must be integral, "
+            "float "
+            "or double."
           );
 
         } else {
@@ -144,27 +142,23 @@ namespace rfl {
         }
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputArrayType> to_array(const InputVarType& _var) const noexcept {
         if (!cbor_value_is_array(_var.val_)) {
           return Error("Could not cast to an array.");
         }
-        return InputArrayType {_var.val_};
+        return InputArrayType { _var.val_ };
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputObjectType> to_object(const InputVarType& _var) const noexcept {
         if (!cbor_value_is_map(_var.val_)) {
           return Error("Could not cast to an object.");
         }
-        return InputObjectType {_var.val_};
+        return InputObjectType { _var.val_ };
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         CborValue val;
         auto      buffer = std::vector<char>();
         auto      err    = cbor_value_enter_container(_arr.val_, &val);
@@ -190,10 +184,8 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
         size_t length = 0;
         auto   err    = cbor_value_get_map_length(_obj.val_, &length);
         if (err != CborNoError) {
@@ -218,7 +210,7 @@ namespace rfl {
             return Error(cbor_error_string(err));
           }
           const auto name = std::string_view(buffer.data(), buffer.size() - 1);
-          _object_reader.read(name, InputVarType {&val});
+          _object_reader.read(name, InputVarType { &val });
           cbor_value_advance(&val);
         }
 
@@ -226,16 +218,14 @@ namespace rfl {
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType& _var) const noexcept {
         try {
           return T::from_cbor_obj(_var);
         } catch (std::exception& e) { return rfl::Error(e.what()); }
       }
 
      private:
-      CborError get_string(const CborValue* _ptr, std::vector<char>* _buffer)
-          const noexcept {
+      CborError get_string(const CborValue* _ptr, std::vector<char>* _buffer) const noexcept {
         size_t length = 0;
         auto   err    = cbor_value_get_string_length(_ptr, &length);
         if (err != CborNoError && err != CborErrorOutOfMemory) {
@@ -243,15 +233,13 @@ namespace rfl {
         }
         _buffer->resize(length + 1);
         (*_buffer)[length] = '\0';
-        return cbor_value_copy_text_string(
-            _ptr, _buffer->data(), &length, NULL
-        );
+        return cbor_value_copy_text_string(_ptr, _buffer->data(), &length, NULL);
       }
 
       InputVarType to_input_var(CborValue* _ptr) const noexcept {
         values_->emplace_back(rfl::Box<CborValue>::make(*_ptr));
         auto* last_value = values_->back().get();
-        return InputVarType {last_value};
+        return InputVarType { last_value };
       }
 
      private:
diff --git a/include/rfl/cbor/Writer.hpp b/include/rfl/cbor/Writer.hpp
index 63c633d..5cefb55 100644
--- a/include/rfl/cbor/Writer.hpp
+++ b/include/rfl/cbor/Writer.hpp
@@ -60,49 +60,44 @@ namespace rfl {
         return new_value(_var, encoder_);
       }
 
-      OutputArrayType add_array_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return new_array(_size, _parent->encoder_);
       }
 
       OutputArrayType add_array_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
         return new_array(_size, _parent->encoder_);
       }
 
-      OutputObjectType add_object_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return new_object(_size, _parent->encoder_);
       }
 
       OutputObjectType add_object_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
         return new_object(_size, _parent->encoder_);
       }
 
       template <class T>
-      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-          const noexcept {
+      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
         return new_value(_var, _parent->encoder_);
       }
 
       template <class T>
       OutputVarType add_value_to_object(
-          const std::string_view& _name,
-          const T&                _var,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const T&                _var,
+        OutputObjectType*       _parent
       ) const noexcept {
         cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
         return new_value(_var, _parent->encoder_);
@@ -113,10 +108,8 @@ namespace rfl {
         return OutputVarType {};
       }
 
-      OutputVarType add_null_to_object(
-          const std::string_view& _name,
-          OutputObjectType*       _parent
-      ) const noexcept {
+      OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+        const noexcept {
         cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
         cbor_encode_null(_parent->encoder_);
         return OutputVarType {};
@@ -131,23 +124,20 @@ namespace rfl {
       }
 
      private:
-      OutputArrayType new_array(const size_t _size, CborEncoder* _parent)
-          const noexcept {
+      OutputArrayType new_array(const size_t _size, CborEncoder* _parent) const noexcept {
         subencoders_->emplace_back(rfl::Box<CborEncoder>::make());
         cbor_encoder_create_array(_parent, subencoders_->back().get(), _size);
-        return OutputArrayType {subencoders_->back().get(), _parent};
+        return OutputArrayType { subencoders_->back().get(), _parent };
       }
 
-      OutputObjectType new_object(const size_t _size, CborEncoder* _parent)
-          const noexcept {
+      OutputObjectType new_object(const size_t _size, CborEncoder* _parent) const noexcept {
         subencoders_->emplace_back(rfl::Box<CborEncoder>::make());
         cbor_encoder_create_map(_parent, subencoders_->back().get(), _size);
-        return OutputObjectType {subencoders_->back().get(), _parent};
+        return OutputObjectType { subencoders_->back().get(), _parent };
       }
 
       template <class T>
-      OutputVarType new_value(const T& _var, CborEncoder* _parent)
-          const noexcept {
+      OutputVarType new_value(const T& _var, CborEncoder* _parent) const noexcept {
         if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
           cbor_encode_text_string(_parent, _var.c_str(), _var.size());
         } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
diff --git a/include/rfl/cbor/load.hpp b/include/rfl/cbor/load.hpp
index 2d17710..ef5d0d1 100644
--- a/include/rfl/cbor/load.hpp
+++ b/include/rfl/cbor/load.hpp
@@ -11,9 +11,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_bytes = [](const auto& _bytes) {
-        return read<T, Ps...>(_bytes);
-      };
+      const auto read_bytes = [](const auto& _bytes) { return read<T, Ps...>(_bytes); };
       return rfl::io::load_bytes(_fname).and_then(read_bytes);
     }
 
diff --git a/include/rfl/cbor/read.hpp b/include/rfl/cbor/read.hpp
index 29d01e6..913da8f 100644
--- a/include/rfl/cbor/read.hpp
+++ b/include/rfl/cbor/read.hpp
@@ -25,14 +25,11 @@ namespace rfl {
 
     /// Parses an object from CBOR using reflection.
     template <class T, class... Ps>
-    Result<internal::wrap_in_rfl_array_t<T>>
-    read(const char* _bytes, const size_t _size) {
+    Result<internal::wrap_in_rfl_array_t<T>> read(const char* _bytes, const size_t _size) {
       CborParser parser;
       CborValue  value;
-      cbor_parser_init(
-          reinterpret_cast<const uint8_t*>(_bytes), _size, 0, &parser, &value
-      );
-      auto doc    = InputVarType {&value};
+      cbor_parser_init(reinterpret_cast<const uint8_t*>(_bytes), _size, 0, &parser, &value);
+      auto doc    = InputVarType { &value };
       auto result = read<T, Ps...>(doc);
       return result;
     }
diff --git a/include/rfl/cbor/write.hpp b/include/rfl/cbor/write.hpp
index 23720fe..c32d946 100644
--- a/include/rfl/cbor/write.hpp
+++ b/include/rfl/cbor/write.hpp
@@ -16,22 +16,15 @@ namespace rfl {
 
     template <class... Ps>
     void write_into_buffer(
-        const auto&        _obj,
-        CborEncoder*       _encoder,
-        std::vector<char>* _buffer
+      const auto&        _obj,
+      CborEncoder*       _encoder,
+      std::vector<char>* _buffer
     ) noexcept {
       using T          = std::remove_cvref_t<decltype(_obj)>;
       using ParentType = parsing::Parent<Writer>;
-      cbor_encoder_init(
-          _encoder,
-          reinterpret_cast<uint8_t*>(_buffer->data()),
-          _buffer->size(),
-          0
-      );
+      cbor_encoder_init(_encoder, reinterpret_cast<uint8_t*>(_buffer->data()), _buffer->size(), 0);
       const auto writer = Writer(_encoder);
-      Parser<T, Processors<Ps...>>::write(
-          writer, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(writer, _obj, typename ParentType::Root {});
     }
 
     /// Returns CBOR bytes.
@@ -40,15 +33,13 @@ namespace rfl {
       std::vector<char> buffer(4096);
       CborEncoder       encoder;
       write_into_buffer<Ps...>(_obj, &encoder, &buffer);
-      const auto total_bytes_needed =
-          buffer.size() + cbor_encoder_get_extra_bytes_needed(&encoder);
+      const auto total_bytes_needed = buffer.size() + cbor_encoder_get_extra_bytes_needed(&encoder);
       if (total_bytes_needed != buffer.size()) {
         buffer.resize(total_bytes_needed);
         write_into_buffer<Ps...>(_obj, &encoder, &buffer);
       }
-      const auto length = cbor_encoder_get_buffer_size(
-          &encoder, reinterpret_cast<uint8_t*>(buffer.data())
-      );
+      const auto length =
+        cbor_encoder_get_buffer_size(&encoder, reinterpret_cast<uint8_t*>(buffer.data()));
       buffer.resize(length);
       return buffer;
     }
diff --git a/include/rfl/comparisons.hpp b/include/rfl/comparisons.hpp
index 9b592d9..aca1d0d 100644
--- a/include/rfl/comparisons.hpp
+++ b/include/rfl/comparisons.hpp
@@ -15,8 +15,8 @@ namespace rfl {
       constexpr auto threshold = static_cast<T>(_threshold);
       if (_value != threshold) {
         return Error(
-            "Value expected to be equal to " + std::to_string(threshold) +
-            ", but got " + std::to_string(_value) + "."
+          "Value expected to be equal to " + std::to_string(threshold) + ", but got " +
+          std::to_string(_value) + "."
         );
       }
       return _value;
@@ -25,11 +25,10 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto value =
-          std::is_floating_point_v<T>
-              ? std::variant<double, int>(static_cast<double>(_threshold))
-              : std::variant<double, int>(static_cast<int>(_threshold));
-      return ValidationType {ValidationType::EqualTo {.value_ = value}};
+      const auto value     = std::is_floating_point_v<T>
+                               ? std::variant<double, int>(static_cast<double>(_threshold))
+                               : std::variant<double, int>(static_cast<int>(_threshold));
+      return ValidationType { ValidationType::EqualTo { .value_ = value } };
     }
   };
 
@@ -40,9 +39,8 @@ namespace rfl {
       constexpr auto threshold = static_cast<T>(_threshold);
       if (_value < threshold) {
         return Error(
-            "Value expected to be greater than or equal to " +
-            std::to_string(threshold) + ", but got " + std::to_string(_value) +
-            "."
+          "Value expected to be greater than or equal to " + std::to_string(threshold) +
+          ", but got " + std::to_string(_value) + "."
         );
       }
       return _value;
@@ -51,11 +49,10 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto value =
-          std::is_floating_point_v<T>
-              ? std::variant<double, int>(static_cast<double>(_threshold))
-              : std::variant<double, int>(static_cast<int>(_threshold));
-      return ValidationType {ValidationType::Minimum {.value_ = value}};
+      const auto value     = std::is_floating_point_v<T>
+                               ? std::variant<double, int>(static_cast<double>(_threshold))
+                               : std::variant<double, int>(static_cast<int>(_threshold));
+      return ValidationType { ValidationType::Minimum { .value_ = value } };
     }
   };
 
@@ -66,8 +63,8 @@ namespace rfl {
       constexpr auto threshold = static_cast<T>(_threshold);
       if (_value <= threshold) {
         return Error(
-            "Value expected to be greater than " + std::to_string(threshold) +
-            ", but got " + std::to_string(_value) + "."
+          "Value expected to be greater than " + std::to_string(threshold) + ", but got " +
+          std::to_string(_value) + "."
         );
       }
       return _value;
@@ -76,12 +73,10 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto value =
-          std::is_floating_point_v<T>
-              ? std::variant<double, int>(static_cast<double>(_threshold))
-              : std::variant<double, int>(static_cast<int>(_threshold));
-      return ValidationType {ValidationType::ExclusiveMinimum {.value_ = value}
-      };
+      const auto value     = std::is_floating_point_v<T>
+                               ? std::variant<double, int>(static_cast<double>(_threshold))
+                               : std::variant<double, int>(static_cast<int>(_threshold));
+      return ValidationType { ValidationType::ExclusiveMinimum { .value_ = value } };
     }
   };
 
@@ -92,9 +87,8 @@ namespace rfl {
       constexpr auto threshold = static_cast<T>(_threshold);
       if (_value > threshold) {
         return Error(
-            "Value expected to be less than or equal to " +
-            std::to_string(threshold) + ", but got " + std::to_string(_value) +
-            "."
+          "Value expected to be less than or equal to " + std::to_string(threshold) + ", but got " +
+          std::to_string(_value) + "."
         );
       }
       return _value;
@@ -103,11 +97,10 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto value =
-          std::is_floating_point_v<T>
-              ? std::variant<double, int>(static_cast<double>(_threshold))
-              : std::variant<double, int>(static_cast<int>(_threshold));
-      return ValidationType {ValidationType::Maximum {.value_ = value}};
+      const auto value     = std::is_floating_point_v<T>
+                               ? std::variant<double, int>(static_cast<double>(_threshold))
+                               : std::variant<double, int>(static_cast<int>(_threshold));
+      return ValidationType { ValidationType::Maximum { .value_ = value } };
     }
   };
 
@@ -118,8 +111,8 @@ namespace rfl {
       constexpr auto threshold = static_cast<T>(_threshold);
       if (_value >= threshold) {
         return Error(
-            "Value expected to be less than " + std::to_string(threshold) +
-            ", but got " + std::to_string(_value) + "."
+          "Value expected to be less than " + std::to_string(threshold) + ", but got " +
+          std::to_string(_value) + "."
         );
       }
       return _value;
@@ -128,12 +121,10 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto value =
-          std::is_floating_point_v<T>
-              ? std::variant<double, int>(static_cast<double>(_threshold))
-              : std::variant<double, int>(static_cast<int>(_threshold));
-      return ValidationType {ValidationType::ExclusiveMaximum {.value_ = value}
-      };
+      const auto value     = std::is_floating_point_v<T>
+                               ? std::variant<double, int>(static_cast<double>(_threshold))
+                               : std::variant<double, int>(static_cast<int>(_threshold));
+      return ValidationType { ValidationType::ExclusiveMaximum { .value_ = value } };
     }
   };
 
@@ -144,8 +135,8 @@ namespace rfl {
       constexpr auto threshold = static_cast<T>(_threshold);
       if (_value == threshold) {
         return Error(
-            "Value expected to not be equal to " + std::to_string(threshold) +
-            ", but got " + std::to_string(_value) + "."
+          "Value expected to not be equal to " + std::to_string(threshold) + ", but got " +
+          std::to_string(_value) + "."
         );
       }
       return _value;
@@ -154,11 +145,10 @@ namespace rfl {
     template <class T>
     static parsing::schema::ValidationType to_schema() {
       using ValidationType = parsing::schema::ValidationType;
-      const auto value =
-          std::is_floating_point_v<T>
-              ? std::variant<double, int>(static_cast<double>(_threshold))
-              : std::variant<double, int>(static_cast<int>(_threshold));
-      return ValidationType {ValidationType::NotEqualTo {.value_ = value}};
+      const auto value     = std::is_floating_point_v<T>
+                               ? std::variant<double, int>(static_cast<double>(_threshold))
+                               : std::variant<double, int>(static_cast<int>(_threshold));
+      return ValidationType { ValidationType::NotEqualTo { .value_ = value } };
     }
   };
 
diff --git a/include/rfl/define_literal.hpp b/include/rfl/define_literal.hpp
index 4662fc9..9557d8c 100644
--- a/include/rfl/define_literal.hpp
+++ b/include/rfl/define_literal.hpp
@@ -8,8 +8,7 @@ namespace rfl {
 
   /// Allows you to combine several literal types.
   template <class... LiteralTypes>
-  using define_literal_t =
-      typename internal::define_literal<LiteralTypes...>::type;
+  using define_literal_t = typename internal::define_literal<LiteralTypes...>::type;
 
 } // namespace rfl
 
diff --git a/include/rfl/define_named_tuple.hpp b/include/rfl/define_named_tuple.hpp
index 7522030..ce7e582 100644
--- a/include/rfl/define_named_tuple.hpp
+++ b/include/rfl/define_named_tuple.hpp
@@ -7,8 +7,7 @@
 namespace rfl {
 
   template <class... FieldTypes>
-  using define_named_tuple_t =
-      typename internal::define_named_tuple<FieldTypes...>::type;
+  using define_named_tuple_t = typename internal::define_named_tuple<FieldTypes...>::type;
 
 } // namespace rfl
 
diff --git a/include/rfl/define_tagged_union.hpp b/include/rfl/define_tagged_union.hpp
index 7ea4be7..3a6dcb0 100644
--- a/include/rfl/define_tagged_union.hpp
+++ b/include/rfl/define_tagged_union.hpp
@@ -8,8 +8,8 @@
 namespace rfl {
 
   template <internal::StringLiteral _discriminator, class... TaggedUnionTypes>
-  using define_tagged_union_t = typename internal::
-      define_tagged_union<_discriminator, TaggedUnionTypes...>::type;
+  using define_tagged_union_t =
+    typename internal::define_tagged_union<_discriminator, TaggedUnionTypes...>::type;
 
 } // namespace rfl
 
diff --git a/include/rfl/enums.hpp b/include/rfl/enums.hpp
index 4abdbd6..b44ece4 100644
--- a/include/rfl/enums.hpp
+++ b/include/rfl/enums.hpp
@@ -14,23 +14,21 @@ namespace rfl {
   // Converts an enum value to a string.
   template <internal::enums::is_scoped_enum EnumType>
   std::string enum_to_string(EnumType _enum) {
-    return rfl::internal::enums::StringConverter<EnumType>::enum_to_string(_enum
-    );
+    return rfl::internal::enums::StringConverter<EnumType>::enum_to_string(_enum);
   }
 
   // Converts a string to a value of the given enum type.
   template <internal::enums::is_scoped_enum EnumType>
   rfl::Result<EnumType> string_to_enum(const std::string& _str) {
-    return rfl::internal::enums::StringConverter<EnumType>::string_to_enum(_str
-    );
+    return rfl::internal::enums::StringConverter<EnumType>::string_to_enum(_str);
   }
 
   // Returns a named tuple mapping names of enumerators of the given enum type
   // to their values.
   template <internal::enums::is_scoped_enum EnumType>
   auto get_enumerators() {
-    constexpr auto names = internal::enums::
-        get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
+    constexpr auto names =
+      internal::enums::get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
     return internal::enums::names_to_enumerator_named_tuple(names);
   }
 
@@ -38,8 +36,8 @@ namespace rfl {
   // to their underlying values.
   template <internal::enums::is_scoped_enum EnumType>
   auto get_underlying_enumerators() {
-    constexpr auto names = internal::enums::
-        get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
+    constexpr auto names =
+      internal::enums::get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
     return internal::enums::names_to_underlying_enumerator_named_tuple(names);
   }
 
@@ -47,8 +45,8 @@ namespace rfl {
   // std::string_view) and values.
   template <internal::enums::is_scoped_enum EnumType>
   constexpr auto get_enumerator_array() {
-    constexpr auto names = internal::enums::
-        get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
+    constexpr auto names =
+      internal::enums::get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
     return internal::enums::names_to_enumerator_array(names);
   }
 
@@ -56,8 +54,8 @@ namespace rfl {
   // std::string_view) and underlying values.
   template <internal::enums::is_scoped_enum EnumType>
   constexpr auto get_underlying_enumerator_array() {
-    constexpr auto names = internal::enums::
-        get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
+    constexpr auto names =
+      internal::enums::get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
     return internal::enums::names_to_underlying_enumerator_array(names);
   }
 
diff --git a/include/rfl/extract_discriminators.hpp b/include/rfl/extract_discriminators.hpp
index 37bcfab..9c6e44e 100644
--- a/include/rfl/extract_discriminators.hpp
+++ b/include/rfl/extract_discriminators.hpp
@@ -13,8 +13,7 @@ namespace rfl {
   /// Extracts a Literal containing all of the discriminators from a
   /// TaggedUnion.
   template <class TaggedUnionType>
-  using extract_discriminators_t =
-      typename internal::extract_discriminators<TaggedUnionType>::type;
+  using extract_discriminators_t = typename internal::extract_discriminators<TaggedUnionType>::type;
 
 } // namespace rfl
 
diff --git a/include/rfl/field_names_t.hpp b/include/rfl/field_names_t.hpp
index e8a1a21..6e3bba5 100644
--- a/include/rfl/field_names_t.hpp
+++ b/include/rfl/field_names_t.hpp
@@ -10,8 +10,8 @@ namespace rfl {
 
   /// Returns a rfl::Literal containing the field names of struct T.
   template <class T>
-  using field_names_t = typename std::invoke_result<
-      decltype(internal::get_field_names<std::remove_cvref_t<T>>)>::type;
+  using field_names_t =
+    typename std::invoke_result<decltype(internal::get_field_names<std::remove_cvref_t<T>>)>::type;
 
 } // namespace rfl
 
diff --git a/include/rfl/flexbuf/Reader.hpp b/include/rfl/flexbuf/Reader.hpp
index b9faa17..372afe6 100644
--- a/include/rfl/flexbuf/Reader.hpp
+++ b/include/rfl/flexbuf/Reader.hpp
@@ -27,40 +27,32 @@ namespace rfl {
 
       template <class T>
       struct has_from_flexbuf<
-          T,
-          std::enable_if_t<
-              std::is_invocable_r<T, decltype(T::from_flexbuf), InputVarType>::
-                  value>> : std::true_type {};
+        T,
+        std::enable_if_t<std::is_invocable_r<T, decltype(T::from_flexbuf), InputVarType>::value>>
+        : std::true_type {};
 
       template <class T>
       struct has_from_flexbuf<
-          T,
-          std::enable_if_t<std::is_invocable_r<
-              rfl::Result<T>,
-              decltype(T::from_flexbuf),
-              InputVarType>::value>> : std::true_type {};
+        T,
+        std::enable_if_t<
+          std::is_invocable_r<rfl::Result<T>, decltype(T::from_flexbuf), InputVarType>::value>>
+        : std::true_type {};
 
       template <class T>
       static constexpr bool has_custom_constructor = has_from_flexbuf<T>::value;
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&     _name,
-          const InputObjectType& _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType& _obj)
+        const noexcept {
         const auto keys = _obj.Keys();
         for (size_t i = 0; i < keys.size(); ++i) {
           if (_name == keys[i].AsString().c_str()) {
             return _obj.Values()[i];
           }
         }
-        return rfl::Error(
-            "Map does not contain any element called '" + _name + "'."
-        );
+        return rfl::Error("Map does not contain any element called '" + _name + "'.");
       }
 
-      bool is_empty(const InputVarType& _var) const noexcept {
-        return _var.IsNull();
-      }
+      bool is_empty(const InputVarType& _var) const noexcept { return _var.IsNull(); }
 
       template <class T>
       rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
@@ -90,10 +82,8 @@ namespace rfl {
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         const auto size = _arr.size();
         for (size_t i = 0; i < size; ++i) {
           const auto err = _array_reader.read(InputVarType(_arr[i]));
@@ -105,33 +95,27 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
         const auto keys       = _obj.Keys();
         const auto values     = _obj.Values();
         const auto num_values = std::min(keys.size(), values.size());
 
         for (size_t i = 0; i < num_values; ++i) {
-          _object_reader.read(
-              std::string_view(keys[i].AsString().c_str()), values[i]
-          );
+          _object_reader.read(std::string_view(keys[i].AsString().c_str()), values[i]);
         }
 
         return std::nullopt;
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputArrayType> to_array(const InputVarType& _var) const noexcept {
         if (!_var.IsVector()) {
           return rfl::Error("Could not cast to Vector.");
         }
         return _var.AsVector();
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputObjectType> to_object(const InputVarType& _var) const noexcept {
         if (!_var.IsMap()) {
           return rfl::Error("Could not cast to Map!");
         }
@@ -139,8 +123,7 @@ namespace rfl {
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType& _var) const noexcept {
         try {
           return T::from_flexbuf(_var);
         } catch (std::exception& e) { return rfl::Error(e.what()); }
diff --git a/include/rfl/flexbuf/Writer.hpp b/include/rfl/flexbuf/Writer.hpp
index 9f51678..3d81cc7 100644
--- a/include/rfl/flexbuf/Writer.hpp
+++ b/include/rfl/flexbuf/Writer.hpp
@@ -39,13 +39,9 @@ namespace rfl {
 
       ~Writer() = default;
 
-      OutputArrayType array_as_root(const size_t _size) const noexcept {
-        return new_array();
-      }
+      OutputArrayType array_as_root(const size_t _size) const noexcept { return new_array(); }
 
-      OutputObjectType object_as_root(const size_t _size) const noexcept {
-        return new_object();
-      }
+      OutputObjectType object_as_root(const size_t _size) const noexcept { return new_object(); }
 
       OutputVarType null_as_root() const noexcept {
         fbb_->Null();
@@ -57,47 +53,42 @@ namespace rfl {
         return insert_value(_var);
       }
 
-      OutputArrayType add_array_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return new_array();
       }
 
       OutputArrayType add_array_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         return new_array(_name);
       }
 
-      OutputObjectType add_object_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return new_object();
       }
 
       OutputObjectType add_object_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         return new_object(_name);
       }
 
       template <class T>
-      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-          const noexcept {
+      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
         return insert_value(_var);
       }
 
       template <class T>
       OutputVarType add_value_to_object(
-          const std::string_view& _name,
-          const T&                _var,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const T&                _var,
+        OutputObjectType*       _parent
       ) const noexcept {
         return insert_value(_name, _var);
       }
@@ -107,10 +98,8 @@ namespace rfl {
         return OutputVarType {};
       }
 
-      OutputVarType add_null_to_object(
-          const std::string_view& _name,
-          OutputObjectType*       _parent
-      ) const noexcept {
+      OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+        const noexcept {
         fbb_->Null(_name.data());
         return OutputVarType {};
       }
@@ -119,14 +108,11 @@ namespace rfl {
         fbb_->EndVector(_arr->start_, false, false);
       }
 
-      void end_object(OutputObjectType* _obj) const noexcept {
-        fbb_->EndMap(_obj->start_);
-      }
+      void end_object(OutputObjectType* _obj) const noexcept { fbb_->EndMap(_obj->start_); }
 
      private:
       template <class T>
-      OutputVarType insert_value(const std::string_view& _name, const T& _var)
-          const noexcept {
+      OutputVarType insert_value(const std::string_view& _name, const T& _var) const noexcept {
         if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
           fbb_->String(_name.data(), _var);
         } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
@@ -159,23 +145,22 @@ namespace rfl {
 
       OutputArrayType new_array(const std::string_view& _name) const noexcept {
         const auto start = fbb_->StartVector(_name.data());
-        return OutputArrayType {start};
+        return OutputArrayType { start };
       }
 
       OutputArrayType new_array() const noexcept {
         const auto start = fbb_->StartVector();
-        return OutputArrayType {start};
+        return OutputArrayType { start };
       }
 
-      OutputObjectType new_object(const std::string_view& _name
-      ) const noexcept {
+      OutputObjectType new_object(const std::string_view& _name) const noexcept {
         const auto start = fbb_->StartMap(_name.data());
-        return OutputObjectType {start};
+        return OutputObjectType { start };
       }
 
       OutputObjectType new_object() const noexcept {
         const auto start = fbb_->StartMap();
-        return OutputObjectType {start};
+        return OutputObjectType { start };
       }
 
      private:
diff --git a/include/rfl/flexbuf/load.hpp b/include/rfl/flexbuf/load.hpp
index 60b5ac7..48c0a10 100644
--- a/include/rfl/flexbuf/load.hpp
+++ b/include/rfl/flexbuf/load.hpp
@@ -10,9 +10,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_bytes = [](const auto& _bytes) {
-        return read<T, Ps...>(_bytes);
-      };
+      const auto read_bytes = [](const auto& _bytes) { return read<T, Ps...>(_bytes); };
       return rfl::io::load_bytes(_fname).and_then(read_bytes);
     }
 
diff --git a/include/rfl/flexbuf/read.hpp b/include/rfl/flexbuf/read.hpp
index f315a60..e3b68ba 100644
--- a/include/rfl/flexbuf/read.hpp
+++ b/include/rfl/flexbuf/read.hpp
@@ -25,7 +25,7 @@ namespace rfl {
     template <class T, class... Ps>
     auto read(const char* _bytes, const size_t _size) {
       const InputVarType root =
-          flexbuffers::GetRoot(reinterpret_cast<const uint8_t*>(_bytes), _size);
+        flexbuffers::GetRoot(reinterpret_cast<const uint8_t*>(_bytes), _size);
       return read<T, Ps...>(root);
     }
 
diff --git a/include/rfl/flexbuf/write.hpp b/include/rfl/flexbuf/write.hpp
index fb8bb59..7538b44 100644
--- a/include/rfl/flexbuf/write.hpp
+++ b/include/rfl/flexbuf/write.hpp
@@ -21,9 +21,7 @@ namespace rfl {
       using ParentType = parsing::Parent<Writer>;
       const auto fbb   = Ref<flexbuffers::Builder>::make();
       auto       w     = Writer(fbb);
-      Parser<T, Processors<Ps...>>::write(
-          w, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root {});
       fbb->Finish();
       return fbb->GetBuffer();
     }
diff --git a/include/rfl/from_named_tuple.hpp b/include/rfl/from_named_tuple.hpp
index cba1e60..18664cc 100644
--- a/include/rfl/from_named_tuple.hpp
+++ b/include/rfl/from_named_tuple.hpp
@@ -16,11 +16,8 @@ namespace rfl {
   template <class T, class NamedTupleType>
   auto from_named_tuple(NamedTupleType&& _n) {
     using RequiredType = std::remove_cvref_t<rfl::named_tuple_t<T>>;
-    if constexpr (!std::is_same<
-                      std::remove_cvref_t<NamedTupleType>,
-                      RequiredType>()) {
-      return from_named_tuple<T>(RequiredType(std::forward<NamedTupleType>(_n))
-      );
+    if constexpr (!std::is_same<std::remove_cvref_t<NamedTupleType>, RequiredType>()) {
+      return from_named_tuple<T>(RequiredType(std::forward<NamedTupleType>(_n)));
     } else if constexpr (internal::has_fields<T>()) {
       if constexpr (std::is_lvalue_reference<NamedTupleType> {}) {
         return internal::copy_from_named_tuple<T>(_n);
@@ -40,9 +37,7 @@ namespace rfl {
   template <class T, class NamedTupleType>
   auto from_named_tuple(const NamedTupleType& _n) {
     using RequiredType = std::remove_cvref_t<rfl::named_tuple_t<T>>;
-    if constexpr (!std::is_same<
-                      std::remove_cvref_t<NamedTupleType>,
-                      RequiredType>()) {
+    if constexpr (!std::is_same<std::remove_cvref_t<NamedTupleType>, RequiredType>()) {
       return from_named_tuple<T>(RequiredType(_n));
     } else if constexpr (internal::has_fields<T>()) {
       return internal::copy_from_named_tuple<T>(_n);
diff --git a/include/rfl/get.hpp b/include/rfl/get.hpp
index ea32538..bf2c256 100644
--- a/include/rfl/get.hpp
+++ b/include/rfl/get.hpp
@@ -33,9 +33,7 @@ namespace rfl {
   /// Gets a field by name.
   template <internal::StringLiteral _field_name, class NamedTupleType>
   inline const auto& get(const NamedTupleType& _tup) {
-    return internal::Getter<NamedTupleType>::template get_const<_field_name>(
-        _tup
-    );
+    return internal::Getter<NamedTupleType>::template get_const<_field_name>(_tup);
   }
 
   /// Gets a field by the field type.
diff --git a/include/rfl/internal/Field.hpp b/include/rfl/internal/Field.hpp
index decc6f0..16b16d7 100644
--- a/include/rfl/internal/Field.hpp
+++ b/include/rfl/internal/Field.hpp
@@ -11,8 +11,7 @@ namespace rfl {
   namespace internal {
 
     template <class T>
-    using field_tuple_t =
-        typename std::invoke_result<decltype(copy_to_field_tuple<T>), T>::type;
+    using field_tuple_t = typename std::invoke_result<decltype(copy_to_field_tuple<T>), T>::type;
 
   }
 } // namespace rfl
diff --git a/include/rfl/internal/Getter.hpp b/include/rfl/internal/Getter.hpp
index fdfff5a..15a057a 100644
--- a/include/rfl/internal/Getter.hpp
+++ b/include/rfl/internal/Getter.hpp
@@ -29,25 +29,21 @@ namespace rfl::internal {
     /// Gets a field by name.
     template <StringLiteral _field_name>
     static inline auto& get(NamedTupleType& _tup) {
-      constexpr auto index =
-          find_index<_field_name, typename NamedTupleType::Fields>();
+      constexpr auto index = find_index<_field_name, typename NamedTupleType::Fields>();
       return Getter<NamedTupleType>::template get<index>(_tup);
     }
 
     /// Gets a field by the field type.
     template <class Field>
     static inline auto& get(NamedTupleType& _tup) {
-      constexpr auto index =
-          find_index<Field::name_, typename NamedTupleType::Fields>();
+      constexpr auto index = find_index<Field::name_, typename NamedTupleType::Fields>();
       static_assert(
-          std::is_same<
-              typename std::tuple_element<
-                  index,
-                  typename NamedTupleType::Fields>::type::Type,
-              typename Field::Type>(),
-          "If two fields have the same name, "
-          "their type must be the same as "
-          "well."
+        std::is_same<
+          typename std::tuple_element<index, typename NamedTupleType::Fields>::type::Type,
+          typename Field::Type>(),
+        "If two fields have the same name, "
+        "their type must be the same as "
+        "well."
       );
       return Getter<NamedTupleType>::template get<index>(_tup);
     }
@@ -61,25 +57,21 @@ namespace rfl::internal {
     /// Gets a field by name.
     template <StringLiteral _field_name>
     static inline const auto& get_const(const NamedTupleType& _tup) {
-      constexpr auto index =
-          find_index<_field_name, typename NamedTupleType::Fields>();
+      constexpr auto index = find_index<_field_name, typename NamedTupleType::Fields>();
       return Getter<NamedTupleType>::template get_const<index>(_tup);
     }
 
     /// Gets a field by the field type.
     template <class Field>
     static inline const auto& get_const(const NamedTupleType& _tup) {
-      constexpr auto index =
-          find_index<Field::name_, typename NamedTupleType::Fields>();
+      constexpr auto index = find_index<Field::name_, typename NamedTupleType::Fields>();
       static_assert(
-          std::is_same<
-              typename std::tuple_element<
-                  index,
-                  typename NamedTupleType::Fields>::type::Type,
-              typename Field::Type>(),
-          "If two fields have the same name, "
-          "their type must be the same as "
-          "well."
+        std::is_same<
+          typename std::tuple_element<index, typename NamedTupleType::Fields>::type::Type,
+          typename Field::Type>(),
+        "If two fields have the same name, "
+        "their type must be the same as "
+        "well."
       );
       return Getter<NamedTupleType>::template get_const<index>(_tup);
     }
@@ -123,9 +115,7 @@ namespace rfl::internal {
 
     /// Retrieves the indicated value from the tuple.
     template <int _index>
-    static inline const auto& get_const(
-        const std::variant<NamedTupleTypes...>& _tup
-    ) {
+    static inline const auto& get_const(const std::variant<NamedTupleTypes...>& _tup) {
       const auto apply = [](const auto& _tup) -> const auto& {
         using NamedTupleType = std::remove_cvref_t<decltype(_tup)>;
         return Getter<NamedTupleType>::template get_const<_index>(_tup);
@@ -135,9 +125,7 @@ namespace rfl::internal {
 
     /// Gets a field by name.
     template <StringLiteral _field_name>
-    static inline const auto& get_const(
-        const std::variant<NamedTupleTypes...>& _tup
-    ) {
+    static inline const auto& get_const(const std::variant<NamedTupleTypes...>& _tup) {
       const auto apply = [](const auto& _t) -> const auto& {
         using NamedTupleType = std::remove_cvref_t<decltype(_t)>;
         return Getter<NamedTupleType>::template get_const<_field_name>(_t);
@@ -147,9 +135,7 @@ namespace rfl::internal {
 
     /// Gets a field by the field type.
     template <class Field>
-    static inline const auto& get_const(
-        const std::variant<NamedTupleTypes...>& _tup
-    ) {
+    static inline const auto& get_const(const std::variant<NamedTupleTypes...>& _tup) {
       const auto apply = [](const auto& _t) -> const auto& {
         using NamedTupleType = std::remove_cvref_t<decltype(_t)>;
         return Getter<NamedTupleType>::template get_const<Field>(_t);
diff --git a/include/rfl/internal/Memoization.hpp b/include/rfl/internal/Memoization.hpp
index b608354..3ad52bf 100644
--- a/include/rfl/internal/Memoization.hpp
+++ b/include/rfl/internal/Memoization.hpp
@@ -19,11 +19,15 @@ namespace rfl {
       /// Returns the underlying value.
       template <class F>
       const T& value(const F& _f) {
-        if (flag_.test()) { return value_; }
+        if (flag_.test()) {
+          return value_;
+        }
 
         std::lock_guard<std::mutex> guard(mtx_);
 
-        if (flag_.test()) { return value_; }
+        if (flag_.test()) {
+          return value_;
+        }
 
         _f(&value_);
 
diff --git a/include/rfl/internal/Skip.hpp b/include/rfl/internal/Skip.hpp
index 65634d5..4e54681 100644
--- a/include/rfl/internal/Skip.hpp
+++ b/include/rfl/internal/Skip.hpp
@@ -22,8 +22,7 @@ namespace rfl::internal {
 
     Skip(const Type& _value) : value_(_value) {}
 
-    Skip(ReflectionType&& _value) noexcept
-        : value_(_value ? std::move(*_value) : Type()) {}
+    Skip(ReflectionType&& _value) noexcept : value_(_value ? std::move(*_value) : Type()) {}
 
     Skip(const ReflectionType& _value) : value_(_value ? *_value : Type()) {}
 
@@ -39,31 +38,23 @@ namespace rfl::internal {
     template <class U, bool _skip_s, bool _skip_d>
     Skip(Skip<U, _skip_s, _skip_d>&& _other) : value_(_other.get()) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Skip(const U& _value) : value_(_value) {}
 
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Skip(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
 
     template <
-        class U,
-        bool _skip_s,
-        bool _skip_d,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+      class U,
+      bool _skip_s,
+      bool _skip_d,
+      typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     Skip(const Skip<U, _skip_s, _skip_d>& _skip) : value_(_skip.value()) {}
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     Skip(const Default& _default) : value_(Type()) {}
 
     ~Skip() = default;
@@ -93,10 +84,7 @@ namespace rfl::internal {
     }
 
     /// Assigns the underlying object.
-    template <
-        class U,
-        typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type =
-            true>
+    template <class U, typename std::enable_if<std::is_convertible_v<U, Type>, bool>::type = true>
     auto& operator=(const U& _value) {
       value_ = _value;
       return *this;
@@ -104,9 +92,8 @@ namespace rfl::internal {
 
     /// Assigns the underlying object to its default value.
     template <
-        class U = Type,
-        typename std::enable_if<std::is_default_constructible_v<U>, bool>::
-            type = true>
+      class U                                                                 = Type,
+      typename std::enable_if<std::is_default_constructible_v<U>, bool>::type = true>
     auto& operator=(const Default& _default) {
       value_ = Type();
       return *this;
diff --git a/include/rfl/internal/StringLiteral.hpp b/include/rfl/internal/StringLiteral.hpp
index 801b235..5c1d1ff 100644
--- a/include/rfl/internal/StringLiteral.hpp
+++ b/include/rfl/internal/StringLiteral.hpp
@@ -14,13 +14,11 @@ namespace rfl {
     /// for the parameters names in the NamedTuples.
     template <size_t N>
     struct StringLiteral {
-      constexpr StringLiteral(const auto... _chars) : arr_ {_chars..., '\0'} {}
+      constexpr StringLiteral(const auto... _chars) : arr_ { _chars..., '\0' } {}
 
       constexpr StringLiteral(const std::array<char, N> _arr) : arr_(_arr) {}
 
-      constexpr StringLiteral(const char (&_str)[N]) {
-        std::copy_n(_str, N, std::data(arr_));
-      }
+      constexpr StringLiteral(const char (&_str)[N]) { std::copy_n(_str, N, std::data(arr_)); }
 
       /// Returns the value as a string.
       std::string str() const { return std::string(std::data(arr_), N - 1); }
@@ -34,10 +32,8 @@ namespace rfl {
     };
 
     template <size_t N1, size_t N2>
-    constexpr inline bool operator==(
-        const StringLiteral<N1>& _first,
-        const StringLiteral<N2>& _second
-    ) {
+    constexpr inline bool
+    operator==(const StringLiteral<N1>& _first, const StringLiteral<N2>& _second) {
       if constexpr (N1 != N2) {
         return false;
       }
@@ -45,10 +41,8 @@ namespace rfl {
     }
 
     template <size_t N1, size_t N2>
-    constexpr inline bool operator!=(
-        const StringLiteral<N1>& _first,
-        const StringLiteral<N2>& _second
-    ) {
+    constexpr inline bool
+    operator!=(const StringLiteral<N1>& _first, const StringLiteral<N2>& _second) {
       return !(_first == _second);
     }
 
diff --git a/include/rfl/internal/VisitTree.hpp b/include/rfl/internal/VisitTree.hpp
index 9284e44..11383cc 100644
--- a/include/rfl/internal/VisitTree.hpp
+++ b/include/rfl/internal/VisitTree.hpp
@@ -7,8 +7,7 @@ namespace rfl {
     struct VisitTree {
       /// Evaluates a visitor pattern using a tree-like structure.
       template <int _begin, int _end, class Visitor, class... Args>
-      static inline auto
-      visit(const auto& _v, const int _i, const Args&... _args) {
+      static inline auto visit(const auto& _v, const int _i, const Args&... _args) {
         static_assert(_end > _begin, "_end needs to be greater than _begin.");
         if constexpr (_end - _begin == 1) {
           return _v.template visit<_begin>(_args...);
diff --git a/include/rfl/internal/bind_fake_object_to_tuple.hpp b/include/rfl/internal/bind_fake_object_to_tuple.hpp
index d7e45f6..980ff5d 100644
--- a/include/rfl/internal/bind_fake_object_to_tuple.hpp
+++ b/include/rfl/internal/bind_fake_object_to_tuple.hpp
@@ -18,17 +18,17 @@ namespace rfl {
     struct fake_object_tuple_view_helper {
       static consteval auto tuple_view() {
         static_assert(
-            rfl::always_false_v<T>,
-            "\n\nThis error occurs for one of two reasons:\n\n"
-            "1) You have created a struct with more than 100 fields, which is "
-            "unsupported. Please split up your struct into several "
-            "smaller structs and then use rfl::Flatten<...> to combine them. "
-            "Refer "
-            "to the documentation on rfl::Flatten<...> for details.\n\n"
-            "2) You have added a custom constructor to your struct, which you "
-            "shouldn't do either. Please refer to the sections on custom "
-            "classes or custom parsers in the documentation "
-            "for solutions to this problem.\n\n"
+          rfl::always_false_v<T>,
+          "\n\nThis error occurs for one of two reasons:\n\n"
+          "1) You have created a struct with more than 100 fields, which is "
+          "unsupported. Please split up your struct into several "
+          "smaller structs and then use rfl::Flatten<...> to combine them. "
+          "Refer "
+          "to the documentation on rfl::Flatten<...> for details.\n\n"
+          "2) You have added a custom constructor to your struct, which you "
+          "shouldn't do either. Please refer to the sections on custom "
+          "classes or custom parsers in the documentation "
+          "for solutions to this problem.\n\n"
         );
       }
     };
@@ -38,17 +38,15 @@ namespace rfl {
       static consteval auto tuple_view() { return std::tie(); }
     };
 
-#define RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(n, ...)            \
-  template <class T>                                                         \
-  struct fake_object_tuple_view_helper<T, n> {                               \
-    static consteval auto tuple_view() {                                     \
-      const auto& [__VA_ARGS__] = get_fake_object<std::remove_cvref_t<T>>(); \
-      const auto ref_tup        = std::tie(__VA_ARGS__);                     \
-      const auto get_ptrs       = [](const auto&... _refs) {                 \
-        return std::make_tuple(&_refs...);                             \
-      };                                                                     \
-      return std::apply(get_ptrs, ref_tup);                                  \
-    }                                                                        \
+#define RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(n, ...)                                  \
+  template <class T>                                                                               \
+  struct fake_object_tuple_view_helper<T, n> {                                                     \
+    static consteval auto tuple_view() {                                                           \
+      const auto& [__VA_ARGS__] = get_fake_object<std::remove_cvref_t<T>>();                       \
+      const auto ref_tup        = std::tie(__VA_ARGS__);                                           \
+      const auto get_ptrs       = [](const auto&... _refs) { return std::make_tuple(&_refs...); }; \
+      return std::apply(get_ptrs, ref_tup);                                                        \
+    }                                                                                              \
   }
 
     /*The following boilerplate code was generated using a Python script:
@@ -69,5325 +67,5275 @@ namespace rfl {
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(3, f0, f1, f2);
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(4, f0, f1, f2, f3);
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(5, f0, f1, f2, f3, f4);
+    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(6, f0, f1, f2, f3, f4, f5);
+    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(7, f0, f1, f2, f3, f4, f5, f6);
+    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(8, f0, f1, f2, f3, f4, f5, f6, f7);
+    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(9, f0, f1, f2, f3, f4, f5, f6, f7, f8);
+    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(10, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        6,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5
+      11,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        7,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6
+      12,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        8,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7
+      13,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        9,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8
+      14,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        10,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9
+      15,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        11,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10
+      16,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        12,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11
+      17,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        13,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12
+      18,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        14,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13
+      19,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        15,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14
+      20,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        16,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15
+      21,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        17,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16
+      22,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        18,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17
+      23,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        19,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18
+      24,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        20,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19
+      25,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        21,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20
+      26,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        22,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21
+      27,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        23,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22
+      28,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        24,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23
+      29,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        25,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24
+      30,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        26,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25
+      31,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        27,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26
+      32,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        28,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27
+      33,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        29,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28
+      34,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        30,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29
+      35,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        31,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30
+      36,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        32,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31
+      37,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        33,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32
+      38,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        34,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33
+      39,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        35,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34
+      40,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        36,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35
+      41,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        37,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36
+      42,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        38,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37
+      43,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        39,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38
+      44,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        40,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39
+      45,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        41,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40
+      46,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        42,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41
+      47,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        43,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42
+      48,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        44,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43
+      49,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        45,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44
+      50,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        46,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45
+      51,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        47,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46
+      52,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        48,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47
+      53,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        49,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48
+      54,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        50,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49
+      55,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        51,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50
+      56,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        52,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51
+      57,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        53,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52
+      58,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        54,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53
+      59,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        55,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54
+      60,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        56,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55
+      61,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        57,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56
+      62,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        58,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57
+      63,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        59,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58
+      64,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        60,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59
+      65,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        61,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60
+      66,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        62,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61
+      67,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        63,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62
+      68,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        64,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63
+      69,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        65,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64
+      70,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        66,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65
+      71,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        67,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66
+      72,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        68,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67
+      73,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        69,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68
+      74,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        70,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69
+      75,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        71,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70
+      76,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        72,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71
+      77,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        73,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72
+      78,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        74,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73
+      79,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        75,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74
+      80,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        76,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75
+      81,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        77,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76
+      82,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        78,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77
+      83,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        79,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78
+      84,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        80,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79
+      85,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        81,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80
+      86,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        82,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81
+      87,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        83,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82
+      88,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        84,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83
+      89,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        85,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84
+      90,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        86,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85
+      91,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        87,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86
+      92,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        88,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87
+      93,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        89,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88
+      94,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        90,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89
+      95,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        91,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90
+      96,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        92,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91
+      97,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        93,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92
+      98,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96,
+      f97
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        94,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93
+      99,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96,
+      f97,
+      f98
     );
     RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        95,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94
-    );
-    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        96,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95
-    );
-    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        97,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96
-    );
-    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        98,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96,
-        f97
-    );
-    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        99,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96,
-        f97,
-        f98
-    );
-    RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER(
-        100,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96,
-        f97,
-        f98,
-        f99
+      100,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96,
+      f97,
+      f98,
+      f99
     );
 
 #undef RFL_INTERNAL_DEFINE_FAKE_OBJECT_TUPLE_VIEW_HELPER
diff --git a/include/rfl/internal/bind_to_tuple.hpp b/include/rfl/internal/bind_to_tuple.hpp
index b44f82b..99a7628 100644
--- a/include/rfl/internal/bind_to_tuple.hpp
+++ b/include/rfl/internal/bind_to_tuple.hpp
@@ -19,17 +19,17 @@ namespace rfl {
       template <class T>
       static constexpr auto tuple_view(T&) {
         static_assert(
-            rfl::always_false_v<T>,
-            "\n\nThis error occurs for one of two reasons:\n\n"
-            "1) You have created a struct with more than 100 fields, which is "
-            "unsupported. Please split up your struct into several "
-            "smaller structs and then use rfl::Flatten<...> to combine them. "
-            "Refer "
-            "to the documentation on rfl::Flatten<...> for details.\n\n"
-            "2) You have added a custom constructor to your struct, which you "
-            "shouldn't do either. Please refer to the sections on custom "
-            "classes or custom parsers in the documentation "
-            "for solutions to this problem.\n\n"
+          rfl::always_false_v<T>,
+          "\n\nThis error occurs for one of two reasons:\n\n"
+          "1) You have created a struct with more than 100 fields, which is "
+          "unsupported. Please split up your struct into several "
+          "smaller structs and then use rfl::Flatten<...> to combine them. "
+          "Refer "
+          "to the documentation on rfl::Flatten<...> for details.\n\n"
+          "2) You have added a custom constructor to your struct, which you "
+          "shouldn't do either. Please refer to the sections on custom "
+          "classes or custom parsers in the documentation "
+          "for solutions to this problem.\n\n"
         );
       }
     };
@@ -69,5295 +69,5245 @@ namespace rfl {
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(6, f0, f1, f2, f3, f4, f5);
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(7, f0, f1, f2, f3, f4, f5, f6);
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(8, f0, f1, f2, f3, f4, f5, f6, f7);
+    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(9, f0, f1, f2, f3, f4, f5, f6, f7, f8);
+    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(10, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
+    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(11, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10);
+    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(12, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11);
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        9,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8
+      13,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        10,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9
+      14,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        11,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10
+      15,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        12,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11
+      16,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        13,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12
+      17,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        14,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13
+      18,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        15,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14
+      19,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        16,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15
+      20,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        17,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16
+      21,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        18,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17
+      22,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        19,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18
+      23,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        20,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19
+      24,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        21,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20
+      25,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        22,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21
+      26,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        23,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22
+      27,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        24,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23
+      28,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        25,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24
+      29,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        26,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25
+      30,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        27,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26
+      31,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        28,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27
+      32,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        29,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28
+      33,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        30,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29
+      34,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        31,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30
+      35,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        32,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31
+      36,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        33,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32
+      37,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        34,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33
+      38,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        35,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34
+      39,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        36,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35
+      40,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        37,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36
+      41,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        38,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37
+      42,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        39,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38
+      43,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        40,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39
+      44,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        41,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40
+      45,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        42,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41
+      46,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        43,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42
+      47,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        44,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43
+      48,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        45,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44
+      49,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        46,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45
+      50,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        47,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46
+      51,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        48,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47
+      52,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        49,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48
+      53,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        50,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49
+      54,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        51,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50
+      55,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        52,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51
+      56,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        53,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52
+      57,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        54,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53
+      58,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        55,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54
+      59,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        56,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55
+      60,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        57,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56
+      61,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        58,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57
+      62,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        59,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58
+      63,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        60,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59
+      64,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        61,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60
+      65,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        62,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61
+      66,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        63,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62
+      67,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        64,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63
+      68,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        65,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64
+      69,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        66,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65
+      70,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        67,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66
+      71,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        68,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67
+      72,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        69,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68
+      73,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        70,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69
+      74,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        71,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70
+      75,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        72,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71
+      76,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        73,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72
+      77,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        74,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73
+      78,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        75,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74
+      79,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        76,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75
+      80,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        77,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76
+      81,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        78,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77
+      82,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        79,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78
+      83,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        80,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79
+      84,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        81,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80
+      85,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        82,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81
+      86,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        83,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82
+      87,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        84,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83
+      88,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        85,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84
+      89,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        86,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85
+      90,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        87,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86
+      91,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        88,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87
+      92,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        89,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88
+      93,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        90,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89
+      94,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        91,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90
+      95,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        92,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91
+      96,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        93,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92
+      97,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        94,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93
+      98,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96,
+      f97
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        95,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94
+      99,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96,
+      f97,
+      f98
     );
     RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        96,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95
-    );
-    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        97,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96
-    );
-    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        98,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96,
-        f97
-    );
-    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        99,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96,
-        f97,
-        f98
-    );
-    RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER(
-        100,
-        f0,
-        f1,
-        f2,
-        f3,
-        f4,
-        f5,
-        f6,
-        f7,
-        f8,
-        f9,
-        f10,
-        f11,
-        f12,
-        f13,
-        f14,
-        f15,
-        f16,
-        f17,
-        f18,
-        f19,
-        f20,
-        f21,
-        f22,
-        f23,
-        f24,
-        f25,
-        f26,
-        f27,
-        f28,
-        f29,
-        f30,
-        f31,
-        f32,
-        f33,
-        f34,
-        f35,
-        f36,
-        f37,
-        f38,
-        f39,
-        f40,
-        f41,
-        f42,
-        f43,
-        f44,
-        f45,
-        f46,
-        f47,
-        f48,
-        f49,
-        f50,
-        f51,
-        f52,
-        f53,
-        f54,
-        f55,
-        f56,
-        f57,
-        f58,
-        f59,
-        f60,
-        f61,
-        f62,
-        f63,
-        f64,
-        f65,
-        f66,
-        f67,
-        f68,
-        f69,
-        f70,
-        f71,
-        f72,
-        f73,
-        f74,
-        f75,
-        f76,
-        f77,
-        f78,
-        f79,
-        f80,
-        f81,
-        f82,
-        f83,
-        f84,
-        f85,
-        f86,
-        f87,
-        f88,
-        f89,
-        f90,
-        f91,
-        f92,
-        f93,
-        f94,
-        f95,
-        f96,
-        f97,
-        f98,
-        f99
+      100,
+      f0,
+      f1,
+      f2,
+      f3,
+      f4,
+      f5,
+      f6,
+      f7,
+      f8,
+      f9,
+      f10,
+      f11,
+      f12,
+      f13,
+      f14,
+      f15,
+      f16,
+      f17,
+      f18,
+      f19,
+      f20,
+      f21,
+      f22,
+      f23,
+      f24,
+      f25,
+      f26,
+      f27,
+      f28,
+      f29,
+      f30,
+      f31,
+      f32,
+      f33,
+      f34,
+      f35,
+      f36,
+      f37,
+      f38,
+      f39,
+      f40,
+      f41,
+      f42,
+      f43,
+      f44,
+      f45,
+      f46,
+      f47,
+      f48,
+      f49,
+      f50,
+      f51,
+      f52,
+      f53,
+      f54,
+      f55,
+      f56,
+      f57,
+      f58,
+      f59,
+      f60,
+      f61,
+      f62,
+      f63,
+      f64,
+      f65,
+      f66,
+      f67,
+      f68,
+      f69,
+      f70,
+      f71,
+      f72,
+      f73,
+      f74,
+      f75,
+      f76,
+      f77,
+      f78,
+      f79,
+      f80,
+      f81,
+      f82,
+      f83,
+      f84,
+      f85,
+      f86,
+      f87,
+      f88,
+      f89,
+      f90,
+      f91,
+      f92,
+      f93,
+      f94,
+      f95,
+      f96,
+      f97,
+      f98,
+      f99
     );
 
 #undef RFL_INTERNAL_DEFINE_TUPLE_VIEW_HELPER
diff --git a/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp b/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp
index b40862f..6dc1e0e 100644
--- a/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp
+++ b/include/rfl/internal/copy_flattened_tuple_to_named_tuple.hpp
@@ -13,23 +13,18 @@ namespace rfl {
   namespace internal {
 
     template <class FieldNames, class... Fields>
-    auto copy_flattened_tuple_to_named_tuple(
-        const auto& _flattened_tuple,
-        Fields&&... _fields
-    ) {
-      constexpr auto size =
-          std::tuple_size_v<std::remove_cvref_t<decltype(_flattened_tuple)>>;
-      constexpr auto i = sizeof...(_fields);
+    auto copy_flattened_tuple_to_named_tuple(const auto& _flattened_tuple, Fields&&... _fields) {
+      constexpr auto size = std::tuple_size_v<std::remove_cvref_t<decltype(_flattened_tuple)>>;
+      constexpr auto i    = sizeof...(_fields);
       if constexpr (i == size) {
         return make_named_tuple(std::move(_fields)...);
       } else {
         const auto name_literal = FieldNames::template name_of<i>();
-        auto       new_field    = rfl::make_field<
-                     lit_name_v<std::remove_cvref_t<decltype(name_literal)>>>(
-            std::get<i>(_flattened_tuple)
+        auto new_field = rfl::make_field<lit_name_v<std::remove_cvref_t<decltype(name_literal)>>>(
+          std::get<i>(_flattened_tuple)
         );
         return copy_flattened_tuple_to_named_tuple<FieldNames>(
-            _flattened_tuple, std::move(_fields)..., std::move(new_field)
+          _flattened_tuple, std::move(_fields)..., std::move(new_field)
         );
       }
     }
diff --git a/include/rfl/internal/define_literal.hpp b/include/rfl/internal/define_literal.hpp
index 9a01765..f890424 100644
--- a/include/rfl/internal/define_literal.hpp
+++ b/include/rfl/internal/define_literal.hpp
@@ -11,17 +11,9 @@ namespace rfl {
     struct define_literal;
 
     /// General case
-    template <
-        StringLiteral... _content1,
-        StringLiteral... _content2,
-        class... Tail>
-    struct define_literal<
-        Literal<_content1...>,
-        Literal<_content2...>,
-        Tail...> {
-      using type = typename define_literal<
-          Literal<_content1..., _content2...>,
-          Tail...>::type;
+    template <StringLiteral... _content1, StringLiteral... _content2, class... Tail>
+    struct define_literal<Literal<_content1...>, Literal<_content2...>, Tail...> {
+      using type = typename define_literal<Literal<_content1..., _content2...>, Tail...>::type;
     };
 
     /// Special case - only a single literal is left
diff --git a/include/rfl/internal/define_named_tuple.hpp b/include/rfl/internal/define_named_tuple.hpp
index 784ab97..4d7c609 100644
--- a/include/rfl/internal/define_named_tuple.hpp
+++ b/include/rfl/internal/define_named_tuple.hpp
@@ -20,22 +20,16 @@ namespace rfl {
     /// Recursive case - first type is NamedTuple, second type is field.
     template <class Head, class... TupContent, class... Tail>
     struct define_named_tuple<NamedTuple<TupContent...>, Head, Tail...> {
-      using type = typename define_named_tuple<
-          NamedTuple<TupContent..., Head>,
-          Tail...>::type;
+      using type = typename define_named_tuple<NamedTuple<TupContent..., Head>, Tail...>::type;
     };
 
     /// Allows you to combine several named tuples and/or additional fields.
     /// Recursive case - first type is NamedTuple, second type is also
     /// NamedTuple.
     template <class... TupContent, class... TupContent2, class... Tail>
-    struct define_named_tuple<
-        NamedTuple<TupContent...>,
-        NamedTuple<TupContent2...>,
-        Tail...> {
-      using type = typename define_named_tuple<
-          NamedTuple<TupContent..., TupContent2...>,
-          Tail...>::type;
+    struct define_named_tuple<NamedTuple<TupContent...>, NamedTuple<TupContent2...>, Tail...> {
+      using type =
+        typename define_named_tuple<NamedTuple<TupContent..., TupContent2...>, Tail...>::type;
     };
 
     /// Allows you to combine several named tuples and/or additional fields.
diff --git a/include/rfl/internal/define_tagged_union.hpp b/include/rfl/internal/define_tagged_union.hpp
index 719a9a0..7cf45f6 100644
--- a/include/rfl/internal/define_tagged_union.hpp
+++ b/include/rfl/internal/define_tagged_union.hpp
@@ -13,58 +13,50 @@ namespace rfl {
 
     /// Recursive case - both tagged union.
     template <
-        StringLiteral _discriminator,
-        class... NamedTupleTypes1,
-        class... NamedTupleTypes2,
-        class... Tail>
+      StringLiteral _discriminator,
+      class... NamedTupleTypes1,
+      class... NamedTupleTypes2,
+      class... Tail>
     struct define_tagged_union<
-        _discriminator,
-        TaggedUnion<_discriminator, NamedTupleTypes1...>,
-        TaggedUnion<_discriminator, NamedTupleTypes2...>,
-        Tail...> {
+      _discriminator,
+      TaggedUnion<_discriminator, NamedTupleTypes1...>,
+      TaggedUnion<_discriminator, NamedTupleTypes2...>,
+      Tail...> {
       using type = typename define_tagged_union<
-          _discriminator,
-          TaggedUnion<_discriminator, NamedTupleTypes1..., NamedTupleTypes2...>,
-          Tail...>::type;
+        _discriminator,
+        TaggedUnion<_discriminator, NamedTupleTypes1..., NamedTupleTypes2...>,
+        Tail...>::type;
     };
 
     /// Recursive case - tagged union plus named tuple.
     template <
-        StringLiteral _discriminator,
-        class... NamedTupleTypes,
-        class... FieldTypes,
-        class... Tail>
+      StringLiteral _discriminator,
+      class... NamedTupleTypes,
+      class... FieldTypes,
+      class... Tail>
     struct define_tagged_union<
-        _discriminator,
-        TaggedUnion<_discriminator, NamedTupleTypes...>,
-        NamedTuple<FieldTypes...>,
-        Tail...> {
+      _discriminator,
+      TaggedUnion<_discriminator, NamedTupleTypes...>,
+      NamedTuple<FieldTypes...>,
+      Tail...> {
       using type = typename define_tagged_union<
-          _discriminator,
-          TaggedUnion<
-              _discriminator,
-              NamedTupleTypes...,
-              NamedTuple<FieldTypes...>>,
-          Tail...>::type;
+        _discriminator,
+        TaggedUnion<_discriminator, NamedTupleTypes..., NamedTuple<FieldTypes...>>,
+        Tail...>::type;
     };
 
     /// Recursive case - named tuple.
     template <StringLiteral _discriminator, class... FieldTypes, class... Tail>
-    struct define_tagged_union<
-        _discriminator,
-        NamedTuple<FieldTypes...>,
-        Tail...> {
+    struct define_tagged_union<_discriminator, NamedTuple<FieldTypes...>, Tail...> {
       using type = typename define_tagged_union<
-          _discriminator,
-          TaggedUnion<_discriminator, NamedTuple<FieldTypes...>>,
-          Tail...>::type;
+        _discriminator,
+        TaggedUnion<_discriminator, NamedTuple<FieldTypes...>>,
+        Tail...>::type;
     };
 
     /// Special case - only a single TaggedUnion is left.
     template <StringLiteral _discriminator, class... NamedTupleTypes>
-    struct define_tagged_union<
-        _discriminator,
-        TaggedUnion<_discriminator, NamedTupleTypes...>> {
+    struct define_tagged_union<_discriminator, TaggedUnion<_discriminator, NamedTupleTypes...>> {
       using type = TaggedUnion<_discriminator, NamedTupleTypes...>;
     };
 
diff --git a/include/rfl/internal/define_variant.hpp b/include/rfl/internal/define_variant.hpp
index 8716356..8a00f3e 100644
--- a/include/rfl/internal/define_variant.hpp
+++ b/include/rfl/internal/define_variant.hpp
@@ -12,20 +12,14 @@ namespace rfl {
 
     /// Recursive case - both variants.
     template <class... Vars1, class... Vars2, class... Tail>
-    struct define_variant<
-        std::variant<Vars1...>,
-        std::variant<Vars2...>,
-        Tail...> {
-      using type =
-          typename define_variant<std::variant<Vars1..., Vars2...>, Tail...>::
-              type;
+    struct define_variant<std::variant<Vars1...>, std::variant<Vars2...>, Tail...> {
+      using type = typename define_variant<std::variant<Vars1..., Vars2...>, Tail...>::type;
     };
 
     /// Recursive case - variant plus other type.
     template <class... Vars, class Head, class... Tail>
     struct define_variant<std::variant<Vars...>, Head, Tail...> {
-      using type =
-          typename define_variant<std::variant<Vars..., Head>, Tail...>::type;
+      using type = typename define_variant<std::variant<Vars..., Head>, Tail...>::type;
     };
 
     /// Recursive case - other type.
diff --git a/include/rfl/internal/enums/Names.hpp b/include/rfl/internal/enums/Names.hpp
index f212b5b..e7a091c 100644
--- a/include/rfl/internal/enums/Names.hpp
+++ b/include/rfl/internal/enums/Names.hpp
@@ -26,89 +26,45 @@ namespace rfl {
         constexpr static size_t size = N;
 
         /// A list of all the possible enums
-        constexpr static std::array<EnumType, N> enums_ =
-            std::array<EnumType, N> {_enums...};
+        constexpr static std::array<EnumType, N> enums_ = std::array<EnumType, N> { _enums... };
 
-        static_assert(
-            N == 0 || LiteralType::size() == N,
-            "Size of literal and enum do not match."
-        );
+        static_assert(N == 0 || LiteralType::size() == N, "Size of literal and enum do not match.");
 
         template <class NewLiteral, auto _new_enum>
         using AddOneType = std::conditional_t<
-            N == 0,
-            Names<EnumType, NewLiteral, 1, _new_enum>,
-            Names<
-                EnumType,
-                define_literal_t<LiteralType, NewLiteral>,
-                N + 1,
-                _enums...,
-                _new_enum>>;
+          N == 0,
+          Names<EnumType, NewLiteral, 1, _new_enum>,
+          Names<EnumType, define_literal_t<LiteralType, NewLiteral>, N + 1, _enums..., _new_enum>>;
       };
 
-      template <
-          class EnumType,
-          size_t N,
-          StringLiteral... _names,
-          auto... _enums>
-      auto names_to_enumerator_named_tuple(Names<
-                                           EnumType,
-                                           Literal<_names...>,
-                                           N,
-                                           _enums...>) {
-        return make_named_tuple(Field<_names, EnumType> {_enums}...);
+      template <class EnumType, size_t N, StringLiteral... _names, auto... _enums>
+      auto names_to_enumerator_named_tuple(Names<EnumType, Literal<_names...>, N, _enums...>) {
+        return make_named_tuple(Field<_names, EnumType> { _enums }...);
       }
 
-      template <
-          class EnumType,
-          size_t N,
-          StringLiteral... _names,
-          auto... _enums>
+      template <class EnumType, size_t N, StringLiteral... _names, auto... _enums>
       auto names_to_underlying_enumerator_named_tuple(Names<
                                                       EnumType,
                                                       Literal<_names...>,
                                                       N,
                                                       _enums...>) {
-        return make_named_tuple(
-            Field<_names, std::underlying_type_t<EnumType>> {
-                static_cast<std::underlying_type_t<EnumType>>(_enums)
-            }...
-        );
+        return make_named_tuple(Field<_names, std::underlying_type_t<EnumType>> {
+          static_cast<std::underlying_type_t<EnumType>>(_enums) }...);
       }
 
-      template <
-          class EnumType,
-          size_t N,
-          StringLiteral... _names,
-          auto... _enums>
+      template <class EnumType, size_t N, StringLiteral... _names, auto... _enums>
       constexpr std::array<std::pair<std::string_view, EnumType>, N>
-      names_to_enumerator_array(Names<
-                                EnumType,
-                                Literal<_names...>,
-                                N,
-                                _enums...>) {
-        return {std::make_pair(
-            LiteralHelper<_names>::field_.string_view(), _enums
-        )...};
+      names_to_enumerator_array(Names<EnumType, Literal<_names...>, N, _enums...>) {
+        return { std::make_pair(LiteralHelper<_names>::field_.string_view(), _enums)... };
       }
 
-      template <
-          class EnumType,
-          size_t N,
-          StringLiteral... _names,
-          auto... _enums>
-      constexpr std::array<
-          std::pair<std::string_view, std::underlying_type_t<EnumType>>,
-          N>
-      names_to_underlying_enumerator_array(Names<
-                                           EnumType,
-                                           Literal<_names...>,
-                                           N,
-                                           _enums...>) {
-        return {std::make_pair(
-            LiteralHelper<_names>::field_.string_view(),
-            static_cast<std::underlying_type_t<EnumType>>(_enums)
-        )...};
+      template <class EnumType, size_t N, StringLiteral... _names, auto... _enums>
+      constexpr std::array<std::pair<std::string_view, std::underlying_type_t<EnumType>>, N>
+      names_to_underlying_enumerator_array(Names<EnumType, Literal<_names...>, N, _enums...>) {
+        return { std::make_pair(
+          LiteralHelper<_names>::field_.string_view(),
+          static_cast<std::underlying_type_t<EnumType>>(_enums)
+        )... };
       }
 
     } // namespace enums
diff --git a/include/rfl/internal/enums/StringConverter.hpp b/include/rfl/internal/enums/StringConverter.hpp
index a17d572..5a5baa9 100644
--- a/include/rfl/internal/enums/StringConverter.hpp
+++ b/include/rfl/internal/enums/StringConverter.hpp
@@ -23,8 +23,7 @@ namespace rfl {
        public:
         static constexpr bool is_flag_enum_ = is_flag_enum<EnumType>;
 
-        static constexpr auto names_ =
-            get_enum_names<EnumType, is_flag_enum_>();
+        static constexpr auto names_ = get_enum_names<EnumType, is_flag_enum_>();
 
         using NamesLiteral = typename decltype(names_)::Literal;
 
@@ -41,9 +40,9 @@ namespace rfl {
         /// Transforms a string to the matching enum.
         static Result<EnumType> string_to_enum(const std::string& _str) {
           static_assert(
-              names_.size != 0,
-              "No enum could be identified. Please choose enum values "
-              "between 0 to 127 or for flag enums choose 1,2,4,8,16,..."
+            names_.size != 0,
+            "No enum could be identified. Please choose enum values "
+            "between 0 to 127 or for flag enums choose 1,2,4,8,16,..."
           );
           if constexpr (is_flag_enum_) {
             return string_to_flag_enum(_str);
@@ -63,9 +62,7 @@ namespace rfl {
           while (val != 0) {
             const auto bit = val & static_cast<T>(1);
             if (bit == 1) {
-              auto str = enum_to_single_string(
-                  static_cast<EnumType>(static_cast<T>(1) << i)
-              );
+              auto str = enum_to_single_string(static_cast<EnumType>(static_cast<T>(1) << i));
               flags.emplace_back(std::move(str));
             }
             ++i;
@@ -81,17 +78,13 @@ namespace rfl {
 
           for (size_t i = 0; i < names_.size; ++i) {
             if (names_.enums_[i] == _enum) {
-              return NamesLiteral::from_value(
-                         static_cast<typename NamesLiteral::ValueType>(i)
-              )
-                  .transform(to_str)
-                  .value();
+              return NamesLiteral::from_value(static_cast<typename NamesLiteral::ValueType>(i))
+                .transform(to_str)
+                .value();
             }
           }
 
-          return std::to_string(
-              static_cast<std::underlying_type_t<EnumType>>(_enum)
-          );
+          return std::to_string(static_cast<std::underlying_type_t<EnumType>>(_enum));
         }
 
         /// Finds the enum matching the literal.
@@ -102,8 +95,7 @@ namespace rfl {
         /// This assumes that _enum can be exactly matched to one of the names
         /// and does not have to be combined using |.
         static Result<EnumType> single_string_to_enum(const std::string& _str) {
-          const auto r =
-              NamesLiteral::from_string(_str).transform(literal_to_enum);
+          const auto r = NamesLiteral::from_string(_str).transform(literal_to_enum);
           if (r) {
             return r;
           } else {
@@ -115,8 +107,7 @@ namespace rfl {
 
         /// Only relevant if this is a flag enum - combines the different
         /// matches using |.
-        static Result<EnumType> string_to_flag_enum(const std::string& _str
-        ) noexcept {
+        static Result<EnumType> string_to_flag_enum(const std::string& _str) noexcept {
           using T          = std::underlying_type_t<EnumType>;
           const auto split = strings::split(_str, "|");
           auto       res   = static_cast<T>(0);
diff --git a/include/rfl/internal/enums/get_enum_names.hpp b/include/rfl/internal/enums/get_enum_names.hpp
index d1f0585..cec5193 100644
--- a/include/rfl/internal/enums/get_enum_names.hpp
+++ b/include/rfl/internal/enums/get_enum_names.hpp
@@ -45,10 +45,9 @@ namespace rfl {
         // for Clang on Windows. For all other compilers, function_name works as
         // intended.
 #if defined(__clang__) && defined(_MSC_VER)
-        const auto func_name = std::string_view {__PRETTY_FUNCTION__};
+        const auto func_name = std::string_view { __PRETTY_FUNCTION__ };
 #else
-        const auto func_name =
-            std::string_view {std::source_location::current().function_name()};
+        const auto func_name = std::string_view { std::source_location::current().function_name() };
 #endif
 #if defined(__clang__)
         const auto split = func_name.substr(0, func_name.size() - 1);
@@ -61,18 +60,18 @@ namespace rfl {
         return split.substr(split.find("get_enum_name_str_view<") + 23);
 #else
         static_assert(
-            false,
-            "You are using an unsupported compiler. Please use GCC, Clang "
-            "or MSVC or use rfl::Literal."
+          false,
+          "You are using an unsupported compiler. Please use GCC, Clang "
+          "or MSVC or use rfl::Literal."
         );
 #endif
       }
 
       template <auto e>
       consteval auto get_enum_name() {
-        constexpr auto name   = get_enum_name_str_view<e>();
-        const auto to_str_lit = [&]<auto... Ns>(std::index_sequence<Ns...>) {
-          return StringLiteral<sizeof...(Ns) + 1> {name[Ns]...};
+        constexpr auto name       = get_enum_name_str_view<e>();
+        const auto     to_str_lit = [&]<auto... Ns>(std::index_sequence<Ns...>) {
+          return StringLiteral<sizeof...(Ns) + 1> { name[Ns]... };
         };
         return to_str_lit(std::make_index_sequence<name.size()> {});
       }
@@ -91,9 +90,8 @@ namespace rfl {
         if constexpr (_is_flag) {
           return calc_greatest_power_of_two<T>();
         } else {
-          return std::numeric_limits<T>::max() > 127
-                     ? static_cast<T>(127)
-                     : std::numeric_limits<T>::max();
+          return std::numeric_limits<T>::max() > 127 ? static_cast<T>(127)
+                                                     : std::numeric_limits<T>::max();
         }
       }
 
@@ -106,12 +104,7 @@ namespace rfl {
         }
       }
 
-      template <
-          class EnumType,
-          class NamesType,
-          auto _max,
-          bool _is_flag,
-          int  _i>
+      template <class EnumType, class NamesType, auto _max, bool _is_flag, int _i>
       consteval auto get_enum_names_impl() {
         using T = std::underlying_type_t<EnumType>;
 
@@ -123,27 +116,16 @@ namespace rfl {
           if constexpr (j == _max) {
             return NamesType {};
           } else {
-            return get_enum_names_impl<
-                EnumType,
-                NamesType,
-                _max,
-                _is_flag,
-                _i + 1>();
+            return get_enum_names_impl<EnumType, NamesType, _max, _is_flag, _i + 1>();
           }
         } else {
-          using NewNames = typename NamesType::template AddOneType<
-              Literal<remove_namespaces<name>()>,
-              static_cast<EnumType>(j)>;
+          using NewNames = typename NamesType::
+            template AddOneType<Literal<remove_namespaces<name>()>, static_cast<EnumType>(j)>;
 
           if constexpr (j == _max) {
             return NewNames {};
           } else {
-            return get_enum_names_impl<
-                EnumType,
-                NewNames,
-                _max,
-                _is_flag,
-                _i + 1>();
+            return get_enum_names_impl<EnumType, NewNames, _max, _is_flag, _i + 1>();
           }
         }
       }
@@ -151,18 +133,17 @@ namespace rfl {
       template <class EnumType, bool _is_flag>
       consteval auto get_enum_names() {
         static_assert(
-            is_scoped_enum<EnumType>,
-            "You must use scoped enums (using class or struct) for the "
-            "parsing to work!"
+          is_scoped_enum<EnumType>,
+          "You must use scoped enums (using class or struct) for the "
+          "parsing to work!"
         );
 
         static_assert(
-            std::is_integral_v<std::underlying_type_t<EnumType>>,
-            "The underlying type of any Enum must be integral!"
+          std::is_integral_v<std::underlying_type_t<EnumType>>,
+          "The underlying type of any Enum must be integral!"
         );
 
-        constexpr auto max =
-            get_max<std::underlying_type_t<EnumType>, _is_flag>();
+        constexpr auto max = get_max<std::underlying_type_t<EnumType>, _is_flag>();
 
         using EmptyNames = Names<EnumType, rfl::Literal<"">, 0>;
 
diff --git a/include/rfl/internal/enums/is_flag_enum.hpp b/include/rfl/internal/enums/is_flag_enum.hpp
index ee68a49..13001c1 100644
--- a/include/rfl/internal/enums/is_flag_enum.hpp
+++ b/include/rfl/internal/enums/is_flag_enum.hpp
@@ -10,10 +10,9 @@ namespace rfl {
     namespace enums {
 
       template <class EnumType>
-      concept is_flag_enum =
-          is_scoped_enum<EnumType> && requires(EnumType e1, EnumType e2) {
-            { e1 | e2 } -> std::same_as<EnumType>;
-          };
+      concept is_flag_enum = is_scoped_enum<EnumType> && requires(EnumType e1, EnumType e2) {
+        { e1 | e2 } -> std::same_as<EnumType>;
+      };
 
     } // namespace enums
   } // namespace internal
diff --git a/include/rfl/internal/enums/is_scoped_enum.hpp b/include/rfl/internal/enums/is_scoped_enum.hpp
index a05db63..aa767ad 100644
--- a/include/rfl/internal/enums/is_scoped_enum.hpp
+++ b/include/rfl/internal/enums/is_scoped_enum.hpp
@@ -9,9 +9,8 @@ namespace rfl {
     namespace enums {
 
       template <class EnumType>
-      concept is_scoped_enum =
-          std::is_enum_v<EnumType> &&
-          !std::is_convertible_v<EnumType, std::underlying_type_t<EnumType>>;
+      concept is_scoped_enum = std::is_enum_v<EnumType> &&
+                               !std::is_convertible_v<EnumType, std::underlying_type_t<EnumType>>;
 
     } // namespace enums
   } // namespace internal
diff --git a/include/rfl/internal/extract_discriminators.hpp b/include/rfl/internal/extract_discriminators.hpp
index dbc7669..05443e7 100644
--- a/include/rfl/internal/extract_discriminators.hpp
+++ b/include/rfl/internal/extract_discriminators.hpp
@@ -14,10 +14,9 @@ namespace rfl {
     struct extract_discriminators;
 
     template <StringLiteral _discriminator, class... NamedTupleType>
-    struct extract_discriminators<
-        TaggedUnion<_discriminator, NamedTupleType...>> {
-      using type = define_literal_t<
-          std::remove_cvref_t<field_type_t<_discriminator, NamedTupleType>>...>;
+    struct extract_discriminators<TaggedUnion<_discriminator, NamedTupleType...>> {
+      using type =
+        define_literal_t<std::remove_cvref_t<field_type_t<_discriminator, NamedTupleType>>...>;
     };
 
   } // namespace internal
diff --git a/include/rfl/internal/field_tuple_t.hpp b/include/rfl/internal/field_tuple_t.hpp
index decc6f0..16b16d7 100644
--- a/include/rfl/internal/field_tuple_t.hpp
+++ b/include/rfl/internal/field_tuple_t.hpp
@@ -11,8 +11,7 @@ namespace rfl {
   namespace internal {
 
     template <class T>
-    using field_tuple_t =
-        typename std::invoke_result<decltype(copy_to_field_tuple<T>), T>::type;
+    using field_tuple_t = typename std::invoke_result<decltype(copy_to_field_tuple<T>), T>::type;
 
   }
 } // namespace rfl
diff --git a/include/rfl/internal/field_type.hpp b/include/rfl/internal/field_type.hpp
index 3b0691f..328e129 100644
--- a/include/rfl/internal/field_type.hpp
+++ b/include/rfl/internal/field_type.hpp
@@ -27,24 +27,19 @@ namespace rfl {
       using NamedTupleType = named_tuple_t<T>;
 
       static constexpr int field_ix_ =
-          internal::find_index<_field_name, typename NamedTupleType::Fields>();
+        internal::find_index<_field_name, typename NamedTupleType::Fields>();
 
-      using Type = typename std::
-          tuple_element<field_ix_, typename NamedTupleType::Fields>::type::Type;
+      using Type =
+        typename std::tuple_element<field_ix_, typename NamedTupleType::Fields>::type::Type;
     };
 
     /// For variants - in this case the FieldType returned by all options must
     /// be the same.
-    template <
-        StringLiteral _field_name,
-        class FirstAlternativeType,
-        class... OtherAlternativeTypes>
-    struct FieldType<
-        _field_name,
-        std::variant<FirstAlternativeType, OtherAlternativeTypes...>> {
+    template <StringLiteral _field_name, class FirstAlternativeType, class... OtherAlternativeTypes>
+    struct FieldType<_field_name, std::variant<FirstAlternativeType, OtherAlternativeTypes...>> {
       constexpr static bool all_types_match = std::conjunction_v<std::is_same<
-          typename FieldType<_field_name, FirstAlternativeType>::Type,
-          typename FieldType<_field_name, OtherAlternativeTypes>::Type>...>;
+        typename FieldType<_field_name, FirstAlternativeType>::Type,
+        typename FieldType<_field_name, OtherAlternativeTypes>::Type>...>;
 
       static_assert(all_types_match, "All field types must be the same.");
 
@@ -52,17 +47,11 @@ namespace rfl {
     };
 
     /// For tagged union - just defers to the variant.
-    template <
-        StringLiteral _field_name,
-        StringLiteral _discriminator_name,
-        class... VarTypes>
-    struct FieldType<
-        _field_name,
-        TaggedUnion<_discriminator_name, VarTypes...>> {
+    template <StringLiteral _field_name, StringLiteral _discriminator_name, class... VarTypes>
+    struct FieldType<_field_name, TaggedUnion<_discriminator_name, VarTypes...>> {
       using Type = typename FieldType<
-          _field_name,
-          typename TaggedUnion<_discriminator_name, VarTypes...>::VariantType>::
-          Type;
+        _field_name,
+        typename TaggedUnion<_discriminator_name, VarTypes...>::VariantType>::Type;
     };
 
   } // namespace internal
diff --git a/include/rfl/internal/find_index.hpp b/include/rfl/internal/find_index.hpp
index 53b9a5d..4d17a35 100644
--- a/include/rfl/internal/find_index.hpp
+++ b/include/rfl/internal/find_index.hpp
@@ -12,8 +12,7 @@ namespace rfl {
     /// Finds the index of the field signified by _field_name
     template <StringLiteral _field_name, class Fields, int I = 0>
     constexpr static int find_index() {
-      using FieldType =
-          std::remove_cvref_t<typename std::tuple_element<I, Fields>::type>;
+      using FieldType = std::remove_cvref_t<typename std::tuple_element<I, Fields>::type>;
 
       constexpr bool name_i_matches = (FieldType::name_ == _field_name);
 
diff --git a/include/rfl/internal/flattened_ptr_tuple_t.hpp b/include/rfl/internal/flattened_ptr_tuple_t.hpp
index 21d9c2d..b775426 100644
--- a/include/rfl/internal/flattened_ptr_tuple_t.hpp
+++ b/include/rfl/internal/flattened_ptr_tuple_t.hpp
@@ -10,8 +10,8 @@ namespace rfl {
   namespace internal {
 
     template <class T>
-    using flattened_ptr_tuple_t = typename std::
-        invoke_result<decltype(to_flattened_ptr_tuple<T>), T>::type;
+    using flattened_ptr_tuple_t =
+      typename std::invoke_result<decltype(to_flattened_ptr_tuple<T>), T>::type;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/flattened_tuple_t.hpp b/include/rfl/internal/flattened_tuple_t.hpp
index dce1a9e..69b79f2 100644
--- a/include/rfl/internal/flattened_tuple_t.hpp
+++ b/include/rfl/internal/flattened_tuple_t.hpp
@@ -13,8 +13,7 @@ namespace rfl {
   namespace internal {
 
     template <class T>
-    using flattened_tuple_t =
-        typename remove_ptrs_tup<flattened_ptr_tuple_t<T>>::TupleType;
+    using flattened_tuple_t = typename remove_ptrs_tup<flattened_ptr_tuple_t<T>>::TupleType;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/get_field_names.hpp b/include/rfl/internal/get_field_names.hpp
index bb73421..4bf3286 100644
--- a/include/rfl/internal/get_field_names.hpp
+++ b/include/rfl/internal/get_field_names.hpp
@@ -37,7 +37,7 @@ namespace rfl::internal {
   // This workaround is necessary for clang.
   template <class T>
   constexpr auto wrap(const T& arg) noexcept {
-    return Wrapper {arg};
+    return Wrapper { arg };
   }
 
   template <class T, auto ptr>
@@ -46,10 +46,9 @@ namespace rfl::internal {
     // Clang on Windows. For all other compilers, function_name works as
     // intended.
 #if defined(__clang__) && defined(_MSC_VER)
-    const auto func_name = std::string_view {__PRETTY_FUNCTION__};
+    const auto func_name = std::string_view { __PRETTY_FUNCTION__ };
 #else
-    const auto func_name =
-        std::string_view {std::source_location::current().function_name()};
+    const auto func_name = std::string_view { std::source_location::current().function_name() };
 #endif
 #if defined(__clang__)
     const auto split = func_name.substr(0, func_name.size() - 2);
@@ -62,9 +61,9 @@ namespace rfl::internal {
     return split.substr(split.rfind("->") + 2);
 #else
     static_assert(
-        false,
-        "You are using an unsupported compiler. Please use GCC, Clang "
-        "or MSVC or switch to the rfl::Field-syntax."
+      false,
+      "You are using an unsupported compiler. Please use GCC, Clang "
+      "or MSVC or switch to the rfl::Field-syntax."
     );
 #endif
   }
@@ -73,7 +72,7 @@ namespace rfl::internal {
   consteval auto get_field_name_str_lit() {
     constexpr auto name       = get_field_name_str_view<T, ptr>();
     const auto     to_str_lit = [&]<auto... Ns>(std::index_sequence<Ns...>) {
-      return StringLiteral<sizeof...(Ns) + 1> {name[Ns]...};
+      return StringLiteral<sizeof...(Ns) + 1> { name[Ns]... };
     };
     return to_str_lit(std::make_index_sequence<name.size()> {});
   }
@@ -84,8 +83,8 @@ namespace rfl::internal {
   template <class T, auto ptr>
   auto get_field_name() {
 #if defined(__clang__)
-    using Type = std::remove_cvref_t<std::remove_pointer_t<
-        typename std::remove_pointer_t<decltype(ptr)>::Type>>;
+    using Type = std::remove_cvref_t<
+      std::remove_pointer_t<typename std::remove_pointer_t<decltype(ptr)>::Type>>;
 #else
     using Type = std::remove_cvref_t<std::remove_pointer_t<decltype(ptr)>>;
 #endif
@@ -101,8 +100,8 @@ namespace rfl::internal {
 
   template <StringLiteral... _names1, StringLiteral... _names2>
   auto concat_two_literals(
-      const rfl::Literal<_names1...>& _lit1,
-      const rfl::Literal<_names2...>& _lit2
+    const rfl::Literal<_names1...>& _lit1,
+    const rfl::Literal<_names2...>& _lit2
   ) {
     return rfl::Literal<_names1..., _names2...>::template from_value<0>();
   }
@@ -138,17 +137,13 @@ namespace rfl::internal {
 #if defined(__clang__)
       const auto get = []<std::size_t... Is>(std::index_sequence<Is...>) {
         return concat_literals(
-            get_field_name<
-                Type,
-                wrap(std::get<Is>(bind_fake_object_to_tuple<T>()))>()...
+          get_field_name<Type, wrap(std::get<Is>(bind_fake_object_to_tuple<T>()))>()...
         );
       };
 #else
       const auto get = []<std::size_t... Is>(std::index_sequence<Is...>) {
-        return concat_literals(
-            get_field_name<Type, std::get<Is>(bind_fake_object_to_tuple<T>())>(
-            )...
-        );
+        return concat_literals(get_field_name<Type, std::get<Is>(bind_fake_object_to_tuple<T>())>(
+        )...);
       };
 #endif
       return get(std::make_index_sequence<num_fields<T>>());
diff --git a/include/rfl/internal/get_meta_fields.hpp b/include/rfl/internal/get_meta_fields.hpp
index 43086fe..bf3d37e 100644
--- a/include/rfl/internal/get_meta_fields.hpp
+++ b/include/rfl/internal/get_meta_fields.hpp
@@ -15,15 +15,13 @@ namespace rfl {
     auto get_meta_fields(AlreadyExtracted&&... _already_extracted) {
       constexpr size_t i = sizeof...(_already_extracted);
       if constexpr (NamedTupleType::size() == i) {
-        return std::array<MetaField, i> {std::move(_already_extracted)...};
+        return std::array<MetaField, i> { std::move(_already_extracted)... };
       } else {
-        using FieldType =
-            std::tuple_element_t<i, typename NamedTupleType::Fields>;
-        auto name = typename FieldType::Name().str();
-        auto type = type_name_t<typename FieldType::Type>().str();
+        using FieldType = std::tuple_element_t<i, typename NamedTupleType::Fields>;
+        auto name       = typename FieldType::Name().str();
+        auto type       = type_name_t<typename FieldType::Type>().str();
         return get_meta_fields<NamedTupleType>(
-            std::move(_already_extracted)...,
-            MetaField(std::move(name), std::move(type))
+          std::move(_already_extracted)..., MetaField(std::move(name), std::move(type))
         );
       }
     }
diff --git a/include/rfl/internal/get_type_name.hpp b/include/rfl/internal/get_type_name.hpp
index 7af0363..e8f018d 100644
--- a/include/rfl/internal/get_type_name.hpp
+++ b/include/rfl/internal/get_type_name.hpp
@@ -14,10 +14,9 @@ namespace rfl {
       // Clang on Windows. For all other compilers, function_name works as
       // intended.
 #if defined(__clang__) && defined(_MSC_VER)
-      const auto func_name = std::string_view {__PRETTY_FUNCTION__};
+      const auto func_name = std::string_view { __PRETTY_FUNCTION__ };
 #else
-      const auto func_name =
-          std::string_view {std::source_location::current().function_name()};
+      const auto func_name = std::string_view { std::source_location::current().function_name() };
 #endif
 #if defined(__clang__)
       const auto split = func_name.substr(0, func_name.size() - 1);
@@ -35,22 +34,19 @@ namespace rfl {
       return split;
 #else
       static_assert(
-          false,
-          "You are using an unsupported compiler. Please use GCC, Clang "
-          "or MSVC or explicitly tag your structs using 'Tag' or 'Name'."
+        false,
+        "You are using an unsupported compiler. Please use GCC, Clang "
+        "or MSVC or explicitly tag your structs using 'Tag' or 'Name'."
       );
 #endif
     }
 
     template <class T>
     consteval auto get_type_name() {
-      static_assert(
-          get_type_name_str_view<int>() == "int",
-          "Expected 'int', got something else."
-      );
+      static_assert(get_type_name_str_view<int>() == "int", "Expected 'int', got something else.");
       constexpr auto name       = get_type_name_str_view<T>();
       const auto     to_str_lit = [&]<auto... Ns>(std::index_sequence<Ns...>) {
-        return StringLiteral<sizeof...(Ns) + 1> {name[Ns]...};
+        return StringLiteral<sizeof...(Ns) + 1> { name[Ns]... };
       };
       return to_str_lit(std::make_index_sequence<name.size()> {});
     }
diff --git a/include/rfl/internal/has_fields.hpp b/include/rfl/internal/has_fields.hpp
index c7b176e..743823b 100644
--- a/include/rfl/internal/has_fields.hpp
+++ b/include/rfl/internal/has_fields.hpp
@@ -20,8 +20,7 @@ namespace rfl {
       } else {
         using T = std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
         if constexpr (is_flatten_field_v<T>) {
-          return all_fields_or_flatten<
-                     ptr_tuple_t<typename std::remove_pointer_t<T>::Type>>() &&
+          return all_fields_or_flatten<ptr_tuple_t<typename std::remove_pointer_t<T>::Type>>() &&
                  all_fields_or_flatten<TupleType, _i + 1>();
         } else {
           return is_field_v<T> && all_fields_or_flatten<TupleType, _i + 1>();
@@ -36,8 +35,7 @@ namespace rfl {
       } else {
         using T = std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
         if constexpr (is_flatten_field_v<T>) {
-          return some_fields_or_flatten<
-                     ptr_tuple_t<typename std::remove_pointer_t<T>::Type>>() ||
+          return some_fields_or_flatten<ptr_tuple_t<typename std::remove_pointer_t<T>::Type>>() ||
                  some_fields_or_flatten<TupleType, _i + 1>();
         } else {
           return is_field_v<T> || some_fields_or_flatten<TupleType, _i + 1>();
@@ -53,11 +51,11 @@ namespace rfl {
         using TupleType = ptr_tuple_t<T>;
         if constexpr (some_fields_or_flatten<TupleType>()) {
           static_assert(
-              all_fields_or_flatten<TupleType>(),
-              "If some of your fields are annotated using rfl::Field<...>, "
-              "then you must annotate all of your fields. "
-              "Also, you cannot combine annotated and "
-              "unannotated fields using rfl::Flatten<...>."
+            all_fields_or_flatten<TupleType>(),
+            "If some of your fields are annotated using rfl::Field<...>, "
+            "then you must annotate all of your fields. "
+            "Also, you cannot combine annotated and "
+            "unannotated fields using rfl::Flatten<...>."
           );
           return true;
         } else {
diff --git a/include/rfl/internal/has_reflection_method_v.hpp b/include/rfl/internal/has_reflection_method_v.hpp
index 3c880fb..75eb334 100644
--- a/include/rfl/internal/has_reflection_method_v.hpp
+++ b/include/rfl/internal/has_reflection_method_v.hpp
@@ -7,15 +7,13 @@ namespace rfl {
   namespace internal {
 
     template <typename Wrapper>
-    using reflection_method_t =
-        decltype(std::declval<const Wrapper>().reflection());
+    using reflection_method_t = decltype(std::declval<const Wrapper>().reflection());
 
     template <typename Wrapper, typename = std::void_t<>>
     struct has_refl_m : std::false_type {};
 
     template <typename Wrapper>
-    struct has_refl_m<Wrapper, std::void_t<reflection_method_t<Wrapper>>>
-        : std::true_type {};
+    struct has_refl_m<Wrapper, std::void_t<reflection_method_t<Wrapper>>> : std::true_type {};
 
     /// Utility parameter for named tuple parsing, can be used by the
     /// parsers to determine whether a class or struct has a method
diff --git a/include/rfl/internal/has_reflection_type_v.hpp b/include/rfl/internal/has_reflection_type_v.hpp
index 4452e4e..32d72e6 100644
--- a/include/rfl/internal/has_reflection_type_v.hpp
+++ b/include/rfl/internal/has_reflection_type_v.hpp
@@ -17,8 +17,7 @@ namespace rfl {
       static std::int32_t foo(typename U::ReflectionType*);
 
      public:
-      static constexpr bool value =
-          sizeof(foo<Wrapper>(nullptr)) == sizeof(std::int32_t);
+      static constexpr bool value = sizeof(foo<Wrapper>(nullptr)) == sizeof(std::int32_t);
     };
 
     /// Utility parameter for named tuple parsing, can be used by the
diff --git a/include/rfl/internal/has_tag_v.hpp b/include/rfl/internal/has_tag_v.hpp
index 2a14af3..88afa02 100644
--- a/include/rfl/internal/has_tag_v.hpp
+++ b/include/rfl/internal/has_tag_v.hpp
@@ -17,8 +17,7 @@ namespace rfl {
       static std::int32_t foo(typename U::Tag*);
 
      public:
-      static constexpr bool value =
-          sizeof(foo<Wrapper>(nullptr)) == sizeof(std::int32_t);
+      static constexpr bool value = sizeof(foo<Wrapper>(nullptr)) == sizeof(std::int32_t);
     };
 
     /// Used for tagged unions - determines whether a struct as a Tag.
diff --git a/include/rfl/internal/has_to_class_method_v.hpp b/include/rfl/internal/has_to_class_method_v.hpp
index 8c4bac3..5c687f8 100644
--- a/include/rfl/internal/has_to_class_method_v.hpp
+++ b/include/rfl/internal/has_to_class_method_v.hpp
@@ -7,15 +7,13 @@ namespace rfl {
   namespace internal {
 
     template <typename Wrapper>
-    using to_class_method_t =
-        decltype(std::declval<const Wrapper>().to_class());
+    using to_class_method_t = decltype(std::declval<const Wrapper>().to_class());
 
     template <typename Wrapper, typename = std::void_t<>>
     struct has_to_class_m : std::false_type {};
 
     template <typename Wrapper>
-    struct has_to_class_m<Wrapper, std::void_t<to_class_method_t<Wrapper>>>
-        : std::true_type {};
+    struct has_to_class_m<Wrapper, std::void_t<to_class_method_t<Wrapper>>> : std::true_type {};
 
     /// Utility parameter for named tuple parsing, can be used by the
     /// parsers to determine whether a class or struct has a method
diff --git a/include/rfl/internal/is_array.hpp b/include/rfl/internal/is_array.hpp
index a1e327e..75b4ea9 100644
--- a/include/rfl/internal/is_array.hpp
+++ b/include/rfl/internal/is_array.hpp
@@ -19,8 +19,7 @@ namespace rfl::internal {
   class is_array<Array<Type>> : public std::true_type {};
 
   template <class T>
-  constexpr bool is_array_v =
-      is_array<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+  constexpr bool is_array_v = is_array<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
 } // namespace rfl::internal
 
diff --git a/include/rfl/internal/is_attribute.hpp b/include/rfl/internal/is_attribute.hpp
index cb3f0d0..ef0c8de 100644
--- a/include/rfl/internal/is_attribute.hpp
+++ b/include/rfl/internal/is_attribute.hpp
@@ -23,7 +23,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_attribute_v =
-        is_attribute<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_attribute<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_basic_type.hpp b/include/rfl/internal/is_basic_type.hpp
index 0e2c924..b6b3d71 100644
--- a/include/rfl/internal/is_basic_type.hpp
+++ b/include/rfl/internal/is_basic_type.hpp
@@ -8,11 +8,10 @@ namespace rfl {
   namespace internal {
 
     template <class T>
-    constexpr bool is_basic_type_v =
-        std::is_floating_point_v<std::remove_cvref_t<T>> ||
-        std::is_integral_v<std::remove_cvref_t<T>> ||
-        std::is_same<std::remove_cvref_t<T>, std::string>() ||
-        std::is_same<std::remove_cvref_t<T>, bool>();
+    constexpr bool is_basic_type_v = std::is_floating_point_v<std::remove_cvref_t<T>> ||
+                                     std::is_integral_v<std::remove_cvref_t<T>> ||
+                                     std::is_same<std::remove_cvref_t<T>, std::string>() ||
+                                     std::is_same<std::remove_cvref_t<T>, bool>();
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_description.hpp b/include/rfl/internal/is_description.hpp
index d4cb707..8c6b4a0 100644
--- a/include/rfl/internal/is_description.hpp
+++ b/include/rfl/internal/is_description.hpp
@@ -22,7 +22,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_description_v =
-        is_description<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_description<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_field.hpp b/include/rfl/internal/is_field.hpp
index 5761b3e..553318b 100644
--- a/include/rfl/internal/is_field.hpp
+++ b/include/rfl/internal/is_field.hpp
@@ -21,8 +21,7 @@ namespace rfl {
     class is_field<Field<_name, Type>> : public std::true_type {};
 
     template <class T>
-    constexpr bool is_field_v =
-        is_field<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+    constexpr bool is_field_v = is_field<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_flatten_field.hpp b/include/rfl/internal/is_flatten_field.hpp
index bdb5ee0..3760a93 100644
--- a/include/rfl/internal/is_flatten_field.hpp
+++ b/include/rfl/internal/is_flatten_field.hpp
@@ -21,7 +21,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_flatten_field_v =
-        is_flatten_field<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_flatten_field<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_literal.hpp b/include/rfl/internal/is_literal.hpp
index 2467d40..ef1b95c 100644
--- a/include/rfl/internal/is_literal.hpp
+++ b/include/rfl/internal/is_literal.hpp
@@ -19,8 +19,7 @@ namespace rfl {
     class is_literal<Literal<_s...>> : public std::true_type {};
 
     template <class T>
-    constexpr bool is_literal_v =
-        is_literal<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+    constexpr bool is_literal_v = is_literal<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_named_tuple.hpp b/include/rfl/internal/is_named_tuple.hpp
index 17678a8..42ca47b 100644
--- a/include/rfl/internal/is_named_tuple.hpp
+++ b/include/rfl/internal/is_named_tuple.hpp
@@ -19,7 +19,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_named_tuple_v =
-        is_named_tuple<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_named_tuple<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_no_optionals_v.hpp b/include/rfl/internal/is_no_optionals_v.hpp
index fa1b712..807c9f0 100644
--- a/include/rfl/internal/is_no_optionals_v.hpp
+++ b/include/rfl/internal/is_no_optionals_v.hpp
@@ -21,7 +21,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_no_optionals_v =
-        is_no_optionals<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_no_optionals<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_pattern.hpp b/include/rfl/internal/is_pattern.hpp
index 1b19db6..6ed4032 100644
--- a/include/rfl/internal/is_pattern.hpp
+++ b/include/rfl/internal/is_pattern.hpp
@@ -19,8 +19,7 @@ namespace rfl {
     class is_pattern<Pattern<_regex, _name>> : public std::true_type {};
 
     template <class T>
-    constexpr bool is_pattern_v =
-        is_pattern<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+    constexpr bool is_pattern_v = is_pattern<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_rename.hpp b/include/rfl/internal/is_rename.hpp
index 6b8054e..0095cf1 100644
--- a/include/rfl/internal/is_rename.hpp
+++ b/include/rfl/internal/is_rename.hpp
@@ -21,8 +21,7 @@ namespace rfl {
     class is_rename<Rename<_name, Type>> : public std::true_type {};
 
     template <class T>
-    constexpr bool is_rename_v =
-        is_rename<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+    constexpr bool is_rename_v = is_rename<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_skip.hpp b/include/rfl/internal/is_skip.hpp
index b9ce4b1..dc06d39 100644
--- a/include/rfl/internal/is_skip.hpp
+++ b/include/rfl/internal/is_skip.hpp
@@ -14,12 +14,10 @@ namespace rfl::internal {
   class is_skip : public std::false_type {};
 
   template <class T, bool _skip_serialization, bool _skip_deserialization>
-  class is_skip<Skip<T, _skip_serialization, _skip_deserialization>>
-      : public std::true_type {};
+  class is_skip<Skip<T, _skip_serialization, _skip_deserialization>> : public std::true_type {};
 
   template <class T>
-  constexpr bool is_skip_v =
-      is_skip<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+  constexpr bool is_skip_v = is_skip<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
 } // namespace rfl::internal
 
diff --git a/include/rfl/internal/is_validator.hpp b/include/rfl/internal/is_validator.hpp
index c347f80..385e598 100644
--- a/include/rfl/internal/is_validator.hpp
+++ b/include/rfl/internal/is_validator.hpp
@@ -20,7 +20,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_validator_v =
-        is_validator<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_validator<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/is_variant.hpp b/include/rfl/internal/is_variant.hpp
index e71bff9..df990df 100644
--- a/include/rfl/internal/is_variant.hpp
+++ b/include/rfl/internal/is_variant.hpp
@@ -17,8 +17,7 @@ namespace rfl {
     class is_variant<std::variant<T...>> : public std::true_type {};
 
     template <class T>
-    constexpr bool is_variant_v =
-        is_variant<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+    constexpr bool is_variant_v = is_variant<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/make_tag.hpp b/include/rfl/internal/make_tag.hpp
index d55fb5b..a842efb 100644
--- a/include/rfl/internal/make_tag.hpp
+++ b/include/rfl/internal/make_tag.hpp
@@ -17,15 +17,13 @@ namespace rfl::internal {
   static inline auto make_tag(const T& _t) noexcept {
     if constexpr (internal::has_reflection_type_v<T>) {
       return make_tag<typename T::ReflectionType>();
-    } else if constexpr (named_tuple_t<T>::Names::template contains<
-                             _discriminator>()) {
+    } else if constexpr (named_tuple_t<T>::Names::template contains<_discriminator>()) {
       return *to_view(_t).template get<_discriminator>();
     } else if constexpr (internal::has_tag_v<T>) {
       using LiteralType = typename T::Tag;
       return LiteralType::template name_of<0>();
     } else {
-      return rfl::Literal<
-          internal::remove_namespaces<internal::get_type_name<T>()>()>();
+      return rfl::Literal<internal::remove_namespaces<internal::get_type_name<T>()>()>();
     }
   }
 
diff --git a/include/rfl/internal/move_and_flatten_field_tuple.hpp b/include/rfl/internal/move_and_flatten_field_tuple.hpp
index dd8d8db..fb75d50 100644
--- a/include/rfl/internal/move_and_flatten_field_tuple.hpp
+++ b/include/rfl/internal/move_and_flatten_field_tuple.hpp
@@ -18,17 +18,13 @@ namespace rfl {
         using T = std::tuple_element_t<i, std::remove_cvref_t<FieldTuple>>;
         if constexpr (is_flatten_field<T>::value) {
           return move_and_flatten_field_tuple(
-              std::move(_t),
-              std::move(_args)...,
-              move_and_flatten_field_tuple(
-                  move_to_field_tuple(std::move(std::get<i>(_t).value_))
-              )
+            std::move(_t),
+            std::move(_args)...,
+            move_and_flatten_field_tuple(move_to_field_tuple(std::move(std::get<i>(_t).value_)))
           );
         } else {
           return move_and_flatten_field_tuple(
-              std::move(_t),
-              std::move(_args)...,
-              std::make_tuple(std::move(std::get<i>(_t)))
+            std::move(_t), std::move(_args)..., std::make_tuple(std::move(std::get<i>(_t)))
           );
         }
       }
diff --git a/include/rfl/internal/move_field_tuple_to_named_tuple.hpp b/include/rfl/internal/move_field_tuple_to_named_tuple.hpp
index 1456b22..f5c96df 100644
--- a/include/rfl/internal/move_field_tuple_to_named_tuple.hpp
+++ b/include/rfl/internal/move_field_tuple_to_named_tuple.hpp
@@ -20,8 +20,7 @@ namespace rfl {
       if constexpr (!has_flatten_fields<std::remove_cvref_t<FieldTuple>>()) {
         return std::apply(ft_to_nt, std::move(_field_tuple));
       } else {
-        auto flattened_tuple =
-            move_and_flatten_field_tuple(std::move(_field_tuple));
+        auto flattened_tuple = move_and_flatten_field_tuple(std::move(_field_tuple));
         return std::apply(ft_to_nt, std::move(flattened_tuple));
       }
     }
diff --git a/include/rfl/internal/move_from_named_tuple.hpp b/include/rfl/internal/move_from_named_tuple.hpp
index 079e6e0..16b8ad6 100644
--- a/include/rfl/internal/move_from_named_tuple.hpp
+++ b/include/rfl/internal/move_from_named_tuple.hpp
@@ -17,36 +17,32 @@ namespace rfl {
     auto make_ptr_fields(PtrNamedTupleType& _n, Args... _args) {
       constexpr auto i = sizeof...(Args);
 
-      constexpr auto size =
-          std::tuple_size_v<std::remove_cvref_t<PtrFieldTupleType>>;
+      constexpr auto size = std::tuple_size_v<std::remove_cvref_t<PtrFieldTupleType>>;
 
       if constexpr (i == size) {
         return std::make_tuple(_args...);
       } else {
-        using Field =
-            std::remove_cvref_t<std::tuple_element_t<i, PtrFieldTupleType>>;
-        using T =
-            std::remove_cvref_t<std::remove_pointer_t<typename Field::Type>>;
+        using Field = std::remove_cvref_t<std::tuple_element_t<i, PtrFieldTupleType>>;
+        using T     = std::remove_cvref_t<std::remove_pointer_t<typename Field::Type>>;
 
         if constexpr (is_named_tuple_v<T>) {
-          using SubPtrNamedTupleType = typename std::
-              invoke_result<decltype(nt_to_ptr_named_tuple<T>), T>::type;
+          using SubPtrNamedTupleType =
+            typename std::invoke_result<decltype(nt_to_ptr_named_tuple<T>), T>::type;
 
           return make_ptr_fields<PtrFieldTupleType>(
-              _n, _args..., SubPtrNamedTupleType(_n).fields()
+            _n, _args..., SubPtrNamedTupleType(_n).fields()
           );
 
         } else if constexpr (is_flatten_field<Field>::value) {
-          using SubPtrFieldTupleType =
-              std::remove_cvref_t<ptr_field_tuple_t<T>>;
+          using SubPtrFieldTupleType = std::remove_cvref_t<ptr_field_tuple_t<T>>;
 
           return make_ptr_fields<PtrFieldTupleType>(
-              _n, _args..., make_ptr_fields<SubPtrFieldTupleType>(_n)
+            _n, _args..., make_ptr_fields<SubPtrFieldTupleType>(_n)
           );
 
         } else {
           return make_ptr_fields<PtrFieldTupleType>(
-              _n, _args..., _n.template get_field<Field::name_>()
+            _n, _args..., _n.template get_field<Field::name_>()
           );
         }
       }
@@ -56,30 +52,25 @@ namespace rfl {
     auto move_from_ptr_fields(Pointers& _ptrs, Args&&... _args) {
       constexpr auto i = sizeof...(Args);
       if constexpr (i == std::tuple_size_v<std::remove_cvref_t<Pointers>>) {
-        return T {std::move(_args)...};
+        return T { std::move(_args)... };
       } else {
-        using FieldType =
-            std::tuple_element_t<i, std::remove_cvref_t<Pointers>>;
+        using FieldType = std::tuple_element_t<i, std::remove_cvref_t<Pointers>>;
 
         if constexpr (is_field_v<FieldType>) {
           return move_from_ptr_fields<T>(
-              _ptrs,
-              std::move(_args)...,
-              rfl::make_field<FieldType::name_>(
-                  std::move(*std::get<i>(_ptrs).value())
-              )
+            _ptrs,
+            std::move(_args)...,
+            rfl::make_field<FieldType::name_>(std::move(*std::get<i>(_ptrs).value()))
           );
 
         } else {
           using PtrFieldTupleType = std::remove_cvref_t<ptr_field_tuple_t<T>>;
 
-          using U = std::remove_cvref_t<std::remove_pointer_t<
-              typename std::tuple_element_t<i, PtrFieldTupleType>::Type>>;
+          using U = std::remove_cvref_t<
+            std::remove_pointer_t<typename std::tuple_element_t<i, PtrFieldTupleType>::Type>>;
 
           return move_from_ptr_fields<T>(
-              _ptrs,
-              std::move(_args)...,
-              move_from_ptr_fields<U>(std::get<i>(_ptrs))
+            _ptrs, std::move(_args)..., move_from_ptr_fields<U>(std::get<i>(_ptrs))
           );
         }
       }
@@ -94,9 +85,7 @@ namespace rfl {
       if constexpr (is_named_tuple_v<std::remove_cvref_t<T>>) {
         return std::move(_n);
 
-      } else if constexpr (std::is_same<
-                               std::remove_cvref_t<NamedTupleType>,
-                               RequiredType>()) {
+      } else if constexpr (std::is_same<std::remove_cvref_t<NamedTupleType>, RequiredType>()) {
         auto ptr_named_tuple = nt_to_ptr_named_tuple(_n);
 
         using PtrFieldTupleType = std::remove_cvref_t<ptr_field_tuple_t<T>>;
@@ -106,8 +95,7 @@ namespace rfl {
         return move_from_ptr_fields<T>(pointers);
 
       } else {
-        return move_from_named_tuple<T, RequiredType>(RequiredType(std::move(_n)
-        ));
+        return move_from_named_tuple<T, RequiredType>(RequiredType(std::move(_n)));
       }
     }
 
diff --git a/include/rfl/internal/move_from_tuple.hpp b/include/rfl/internal/move_from_tuple.hpp
index 43a4c3f..79e92fd 100644
--- a/include/rfl/internal/move_from_tuple.hpp
+++ b/include/rfl/internal/move_from_tuple.hpp
@@ -29,42 +29,30 @@ namespace rfl {
       }
     }
 
-    template <
-        class TargetTupleType,
-        class PtrTupleType,
-        int _j = 0,
-        class... Args>
+    template <class TargetTupleType, class PtrTupleType, int _j = 0, class... Args>
     auto unflatten_ptr_tuple(PtrTupleType& _t, Args... _args) {
       constexpr auto i = sizeof...(Args);
 
-      constexpr auto size =
-          std::tuple_size_v<std::remove_cvref_t<TargetTupleType>>;
+      constexpr auto size = std::tuple_size_v<std::remove_cvref_t<TargetTupleType>>;
 
       if constexpr (i == size) {
         return std::make_tuple(_args...);
       } else {
-        using T = std::remove_cvref_t<
-            std::remove_pointer_t<std::tuple_element_t<i, TargetTupleType>>>;
+        using T =
+          std::remove_cvref_t<std::remove_pointer_t<std::tuple_element_t<i, TargetTupleType>>>;
 
         if constexpr (is_flatten_field_v<T>) {
-          using SubTargetTupleType =
-              ptr_tuple_t<std::remove_pointer_t<typename T::Type>>;
+          using SubTargetTupleType = ptr_tuple_t<std::remove_pointer_t<typename T::Type>>;
 
-          constexpr int flattened_size =
-              calc_flattened_size<SubTargetTupleType>();
+          constexpr int flattened_size = calc_flattened_size<SubTargetTupleType>();
 
-          return unflatten_ptr_tuple<
-              TargetTupleType,
-              PtrTupleType,
-              _j + flattened_size>(
-              _t,
-              _args...,
-              unflatten_ptr_tuple<SubTargetTupleType, PtrTupleType, _j>(_t)
+          return unflatten_ptr_tuple<TargetTupleType, PtrTupleType, _j + flattened_size>(
+            _t, _args..., unflatten_ptr_tuple<SubTargetTupleType, PtrTupleType, _j>(_t)
           );
 
         } else {
           return unflatten_ptr_tuple<TargetTupleType, PtrTupleType, _j + 1>(
-              _t, _args..., std::get<_j>(_t)
+            _t, _args..., std::get<_j>(_t)
           );
         }
       }
@@ -74,26 +62,21 @@ namespace rfl {
     auto move_from_pointers(Pointers& _ptrs, Args&&... _args) {
       constexpr auto i = sizeof...(Args);
       if constexpr (i == std::tuple_size_v<std::remove_cvref_t<Pointers>>) {
-        return std::remove_cvref_t<T> {std::move(_args)...};
+        return std::remove_cvref_t<T> { std::move(_args)... };
       } else {
-        using FieldType =
-            std::tuple_element_t<i, std::remove_cvref_t<Pointers>>;
+        using FieldType = std::tuple_element_t<i, std::remove_cvref_t<Pointers>>;
 
         if constexpr (std::is_pointer_v<FieldType>) {
-          return move_from_pointers<T>(
-              _ptrs, std::move(_args)..., std::move(*std::get<i>(_ptrs))
-          );
+          return move_from_pointers<T>(_ptrs, std::move(_args)..., std::move(*std::get<i>(_ptrs)));
 
         } else {
           using PtrTupleType = ptr_tuple_t<std::remove_cvref_t<T>>;
 
-          using U = std::remove_cvref_t<typename std::remove_pointer_t<
-              typename std::tuple_element_t<i, PtrTupleType>>::Type>;
+          using U = std::remove_cvref_t<
+            typename std::remove_pointer_t<typename std::tuple_element_t<i, PtrTupleType>>::Type>;
 
           return move_from_pointers<T>(
-              _ptrs,
-              std::move(_args)...,
-              move_from_pointers<U>(std::get<i>(_ptrs))
+            _ptrs, std::move(_args)..., move_from_pointers<U>(std::get<i>(_ptrs))
           );
         }
       }
@@ -106,9 +89,7 @@ namespace rfl {
 
     template <class T, std::size_t _n>
     auto flatten_array(std::array<T, _n>* _arr) {
-      const auto fct = [](auto&... _v) {
-        return std::tuple_cat(flatten_array(&_v)...);
-      };
+      const auto fct = [](auto&... _v) { return std::tuple_cat(flatten_array(&_v)...); };
       return std::apply(fct, *_arr);
     }
 
@@ -123,9 +104,7 @@ namespace rfl {
     }
 
     auto flatten_c_arrays(const auto& _tup) {
-      const auto fct = [](auto... _v) {
-        return std::tuple_cat(make_tuple_from_element(_v)...);
-      };
+      const auto fct = [](auto... _v) { return std::tuple_cat(make_tuple_from_element(_v)...); };
       return std::apply(fct, _tup);
     }
 
@@ -137,8 +116,7 @@ namespace rfl {
 
       using TargetTupleType = tuple_t<std::remove_cvref_t<T>>;
 
-      auto pointers =
-          flatten_c_arrays(unflatten_ptr_tuple<TargetTupleType>(ptr_tuple));
+      auto pointers = flatten_c_arrays(unflatten_ptr_tuple<TargetTupleType>(ptr_tuple));
 
       return move_from_pointers<T>(pointers);
     }
diff --git a/include/rfl/internal/no_duplicate_field_names.hpp b/include/rfl/internal/no_duplicate_field_names.hpp
index c7a78e9..c68bba6 100644
--- a/include/rfl/internal/no_duplicate_field_names.hpp
+++ b/include/rfl/internal/no_duplicate_field_names.hpp
@@ -18,10 +18,8 @@ namespace rfl {
         } else if constexpr (_j == -1) {
           return no_duplicate_field_names<Fields, _i + 1, _i>();
         } else {
-          using FieldType1 = std::remove_cvref_t<
-              typename std::tuple_element<_i, Fields>::type>;
-          using FieldType2 = std::remove_cvref_t<
-              typename std::tuple_element<_j, Fields>::type>;
+          using FieldType1 = std::remove_cvref_t<typename std::tuple_element<_i, Fields>::type>;
+          using FieldType2 = std::remove_cvref_t<typename std::tuple_element<_j, Fields>::type>;
 
           constexpr auto field_name_i = FieldType1::name_;
           constexpr auto field_name_j = FieldType2::name_;
diff --git a/include/rfl/internal/nt_to_ptr_named_tuple.hpp b/include/rfl/internal/nt_to_ptr_named_tuple.hpp
index 2b8f739..b091f39 100644
--- a/include/rfl/internal/nt_to_ptr_named_tuple.hpp
+++ b/include/rfl/internal/nt_to_ptr_named_tuple.hpp
@@ -24,7 +24,7 @@ namespace rfl {
         using FieldType = typename std::tuple_element<i, Fields>::type;
         using T         = std::remove_cvref_t<typename FieldType::Type>;
         return nt_to_ptr_named_tuple(
-            _nt, _a..., Field<FieldType::name_, T*>(&std::get<i>(_nt.values()))
+          _nt, _a..., Field<FieldType::name_, T*>(&std::get<i>(_nt.values()))
         );
       }
     }
@@ -32,8 +32,7 @@ namespace rfl {
     /// Generates a named tuple that contains pointers to the original values in
     /// the struct from a named tuple.
     template <class NamedTupleType, class... AlreadyExtracted>
-    auto
-    nt_to_ptr_named_tuple(const NamedTupleType& _nt, AlreadyExtracted... _a) {
+    auto nt_to_ptr_named_tuple(const NamedTupleType& _nt, AlreadyExtracted... _a) {
       using Fields = typename NamedTupleType::Fields;
 
       constexpr auto i          = sizeof...(AlreadyExtracted);
@@ -45,9 +44,7 @@ namespace rfl {
         using FieldType = typename std::tuple_element<i, Fields>::type;
         using T         = std::remove_cvref_t<typename FieldType::Type>;
         return nt_to_ptr_named_tuple(
-            _nt,
-            _a...,
-            Field<FieldType::name_, const T*>(&std::get<i>(_nt.values()))
+          _nt, _a..., Field<FieldType::name_, const T*>(&std::get<i>(_nt.values()))
         );
       }
     }
diff --git a/include/rfl/internal/num_fields.hpp b/include/rfl/internal/num_fields.hpp
index 7906ca0..d6d7a76 100644
--- a/include/rfl/internal/num_fields.hpp
+++ b/include/rfl/internal/num_fields.hpp
@@ -76,21 +76,22 @@ namespace rfl {
       template <std::size_t n>
       static consteval bool constructible() {
         return []<std::size_t... is>(std::index_sequence<is...>) {
-          return requires { T {any(is)...}; };
+          return requires { T { any(is)... }; };
         }(std::make_index_sequence<n>());
       }
 
       template <std::size_t l, std::size_t nested, std::size_t r>
       static consteval bool constructible_with_nested() {
         return
-            []<std::size_t... i,
-               std::size_t... j,
-               std::
-                   size_t... k>(std::index_sequence<i...>, std::index_sequence<j...>, std::index_sequence<k...>) {
-              return requires { T {any(i)..., {any(j)...}, any(k)...}; };
-            }(std::make_index_sequence<l>(),
-              std::make_index_sequence<nested>(),
-              std::make_index_sequence<r>());
+          []<
+            std::size_t... i,
+            std::size_t... j,
+            std::
+              size_t... k>(std::index_sequence<i...>, std::index_sequence<j...>, std::index_sequence<k...>) {
+            return requires { T { any(i)..., { any(j)... }, any(k)... }; };
+          }(std::make_index_sequence<l>(),
+            std::make_index_sequence<nested>(),
+            std::make_index_sequence<r>());
       }
 
       template <std::size_t n = 0>
@@ -108,8 +109,7 @@ namespace rfl {
         if constexpr (size < 1) {
           return 1;
         } else if constexpr (constructible_with_nested<index, size, rest>() &&
-                             !constructible_with_nested<index, size, rest + 1>(
-                             )) {
+                             !constructible_with_nested<index, size, rest + 1>()) {
           return size;
         } else {
           return get_nested_array_size<index, size - 1, rest + 1>();
@@ -120,19 +120,17 @@ namespace rfl {
       static consteval std::size_t find_the_sole_non_empty_base_index() {
         static_assert(index < max_args);
         constexpr auto check =
-            []<std::size_t... l,
-               std::
-                   size_t... r>(std::index_sequence<l...>, std::index_sequence<r...>) {
-              return requires {
-                T {any_empty_base<T>(l)...,
-                   any_base<T>(0),
-                   any_empty_base<T>(r)...};
-              };
+          []<
+            std::size_t... l,
+            std::size_t... r>(std::index_sequence<l...>, std::index_sequence<r...>) {
+            return requires {
+              T { any_empty_base<T>(l)..., any_base<T>(0), any_empty_base<T>(r)... };
             };
+          };
 
         if constexpr (check(
-                          std::make_index_sequence<index>(),
-                          std::make_index_sequence<max_args - index - 1>()
+                        std::make_index_sequence<index>(),
+                        std::make_index_sequence<max_args - index - 1>()
                       )) {
           return index;
         } else {
@@ -154,13 +152,11 @@ namespace rfl {
       template <std::size_t n, std::size_t max_arg_num>
       static consteval bool has_n_base_param() {
         constexpr auto right_len = max_arg_num >= n ? max_arg_num - n : 0;
-        return
-            []<std::size_t... l,
-               std::
-                   size_t... r>(std::index_sequence<l...>, std::index_sequence<r...>) {
-              return requires { T {any_base<T>(l)..., any(r)...}; };
-            }(std::make_index_sequence<n>(),
-              std::make_index_sequence<right_len>());
+        return []<
+                 std::size_t... l,
+                 std::size_t... r>(std::index_sequence<l...>, std::index_sequence<r...>) {
+          return requires { T { any_base<T>(l)..., any(r)... }; };
+        }(std::make_index_sequence<n>(), std::make_index_sequence<right_len>());
       }
 
       template <std::size_t max_arg_num, std::size_t index = 0>
@@ -179,17 +175,16 @@ namespace rfl {
           return 0;
         } else {
           return 1 + constructible_no_brace_elision<
-                         index + get_nested_array_size<index, max - index, 0>(),
-                         max>();
+                       index + get_nested_array_size<index, max - index, 0>(),
+                       max>();
         }
       }
 
       static consteval std::size_t count_fields() {
         constexpr std::size_t max_agg_args = count_max_args_in_agg_init();
         constexpr std::size_t no_brace_ellison_args =
-            constructible_no_brace_elision<0, max_agg_args>();
-        constexpr std::size_t base_args =
-            base_param_num<no_brace_ellison_args>();
+          constructible_no_brace_elision<0, max_agg_args>();
+        constexpr std::size_t base_args = base_param_num<no_brace_ellison_args>();
         if constexpr (no_brace_ellison_args == 0 && base_args == 0) {
           // Empty struct
           return 0;
@@ -197,8 +192,7 @@ namespace rfl {
           // Special case when the derived class is empty.
           // In such cases the filed number is the fields in base class.
           // Note that there should be only one base class in this case.
-          return get_nested_base_field_count<
-              find_the_sole_non_empty_base_index<max_agg_args>()>();
+          return get_nested_base_field_count<find_the_sole_non_empty_base_index<max_agg_args>()>();
         } else {
           return no_brace_ellison_args - base_args;
         }
diff --git a/include/rfl/internal/processed_t.hpp b/include/rfl/internal/processed_t.hpp
index 3f6cc87..28f8916 100644
--- a/include/rfl/internal/processed_t.hpp
+++ b/include/rfl/internal/processed_t.hpp
@@ -15,9 +15,8 @@ namespace rfl::internal {
   struct Processed<StructType, Processors<Ps...>> {
     using NamedTupleType = named_tuple_t<StructType>;
     using type           = typename std::invoke_result<
-                  decltype(Processors<
-                           Ps...>::template process<StructType, NamedTupleType>),
-                  NamedTupleType>::type;
+                decltype(Processors<Ps...>::template process<StructType, NamedTupleType>),
+                NamedTupleType>::type;
   };
 
   template <class StructType, class ProcessorsType>
diff --git a/include/rfl/internal/ptr_named_tuple_t.hpp b/include/rfl/internal/ptr_named_tuple_t.hpp
index c8ceb56..7fb90cd 100644
--- a/include/rfl/internal/ptr_named_tuple_t.hpp
+++ b/include/rfl/internal/ptr_named_tuple_t.hpp
@@ -12,8 +12,7 @@ namespace rfl {
   namespace internal {
 
     template <class T>
-    using ptr_named_tuple_t =
-        typename std::invoke_result<decltype(to_ptr_named_tuple<T>), T>::type;
+    using ptr_named_tuple_t = typename std::invoke_result<decltype(to_ptr_named_tuple<T>), T>::type;
 
   } // namespace internal
 } // namespace rfl
diff --git a/include/rfl/internal/remove_fields.hpp b/include/rfl/internal/remove_fields.hpp
index 4558fc1..c4bf131 100644
--- a/include/rfl/internal/remove_fields.hpp
+++ b/include/rfl/internal/remove_fields.hpp
@@ -14,60 +14,37 @@ namespace rfl {
 
     /// Recursively builds a new NamedTuple type from the FieldTypes, leaving
     /// out the field signified by _name.
-    template <
-        class _OldNamedTupleType,
-        StringLiteral _name,
-        class _NewNamedTupleType,
-        int _i>
+    template <class _OldNamedTupleType, StringLiteral _name, class _NewNamedTupleType, int _i>
     struct remove_single_field;
 
     /// Special case - _i == 0
-    template <
-        class _OldNamedTupleType,
-        StringLiteral _name,
-        class _NewNamedTupleType>
-    struct remove_single_field<
-        _OldNamedTupleType,
-        _name,
-        _NewNamedTupleType,
-        0> {
+    template <class _OldNamedTupleType, StringLiteral _name, class _NewNamedTupleType>
+    struct remove_single_field<_OldNamedTupleType, _name, _NewNamedTupleType, 0> {
       using type = _NewNamedTupleType;
     };
 
     /// General case.
-    template <
-        class _OldNamedTupleType,
-        StringLiteral _name,
-        class _NewNamedTupleType,
-        int _i>
+    template <class _OldNamedTupleType, StringLiteral _name, class _NewNamedTupleType, int _i>
     struct remove_single_field {
       using OldNamedTupleType = std::remove_cvref_t<_OldNamedTupleType>;
 
-      constexpr static int num_fields =
-          std::tuple_size_v<typename OldNamedTupleType::Fields>;
+      constexpr static int num_fields = std::tuple_size_v<typename OldNamedTupleType::Fields>;
 
-      using FieldType = std::remove_cvref_t<typename std::tuple_element<
-          num_fields - _i,
-          typename OldNamedTupleType::Fields>::type>;
+      using FieldType = std::remove_cvref_t<
+        typename std::tuple_element<num_fields - _i, typename OldNamedTupleType::Fields>::type>;
 
       using NewNamedTupleType = std::conditional_t<
-          _name == FieldType::name_,
-          _NewNamedTupleType,
-          define_named_tuple_t<_NewNamedTupleType, FieldType>>;
+        _name == FieldType::name_,
+        _NewNamedTupleType,
+        define_named_tuple_t<_NewNamedTupleType, FieldType>>;
 
-      using type = typename remove_single_field<
-          OldNamedTupleType,
-          _name,
-          NewNamedTupleType,
-          _i - 1>::type;
+      using type =
+        typename remove_single_field<OldNamedTupleType, _name, NewNamedTupleType, _i - 1>::type;
     };
 
     /// Recursively removes all of the fields signified by _head and _tail from
     /// the NamedTupleType.
-    template <
-        class _NamedTupleType,
-        StringLiteral _head,
-        StringLiteral... _tail>
+    template <class _NamedTupleType, StringLiteral _head, StringLiteral... _tail>
     struct remove_fields;
 
     /// Special case - only head is left.
@@ -75,32 +52,21 @@ namespace rfl {
     struct remove_fields<_NamedTupleType, _head> {
       using NamedTupleType = std::remove_cvref_t<_NamedTupleType>;
 
-      constexpr static int num_fields =
-          std::tuple_size_v<typename NamedTupleType::Fields>;
+      constexpr static int num_fields = std::tuple_size_v<typename NamedTupleType::Fields>;
 
-      using type = typename remove_single_field<
-          NamedTupleType,
-          _head,
-          NamedTuple<>,
-          num_fields>::type;
+      using type =
+        typename remove_single_field<NamedTupleType, _head, NamedTuple<>, num_fields>::type;
     };
 
     /// General case.
-    template <
-        class _NamedTupleType,
-        StringLiteral _head,
-        StringLiteral... _tail>
+    template <class _NamedTupleType, StringLiteral _head, StringLiteral... _tail>
     struct remove_fields {
       using NamedTupleType = std::remove_cvref_t<_NamedTupleType>;
 
-      constexpr static int num_fields =
-          std::tuple_size_v<typename NamedTupleType::Fields>;
+      constexpr static int num_fields = std::tuple_size_v<typename NamedTupleType::Fields>;
 
-      using NewNamedTupleType = typename remove_single_field<
-          NamedTupleType,
-          _head,
-          NamedTuple<>,
-          num_fields>::type;
+      using NewNamedTupleType =
+        typename remove_single_field<NamedTupleType, _head, NamedTuple<>, num_fields>::type;
 
       using type = typename remove_fields<NewNamedTupleType, _tail...>::type;
     };
diff --git a/include/rfl/internal/remove_namespaces.hpp b/include/rfl/internal/remove_namespaces.hpp
index ceb47a8..ed6c455 100644
--- a/include/rfl/internal/remove_namespaces.hpp
+++ b/include/rfl/internal/remove_namespaces.hpp
@@ -19,7 +19,7 @@ namespace rfl {
       }
       constexpr auto substr     = name.substr(pos + 1);
       const auto     to_str_lit = [&]<auto... Ns>(std::index_sequence<Ns...>) {
-        return StringLiteral<sizeof...(Ns) + 1> {substr[Ns]...};
+        return StringLiteral<sizeof...(Ns) + 1> { substr[Ns]... };
       };
       return to_str_lit(std::make_index_sequence<substr.size()> {});
     }
diff --git a/include/rfl/internal/remove_ptrs_tup.hpp b/include/rfl/internal/remove_ptrs_tup.hpp
index da42396..a1821f9 100644
--- a/include/rfl/internal/remove_ptrs_tup.hpp
+++ b/include/rfl/internal/remove_ptrs_tup.hpp
@@ -16,8 +16,7 @@ namespace rfl {
 
     template <class... Ts>
     struct remove_ptrs_tup<std::tuple<Ts...>> {
-      using TupleType =
-          std::tuple<std::remove_cvref_t<std::remove_pointer_t<Ts>>...>;
+      using TupleType = std::tuple<std::remove_cvref_t<std::remove_pointer_t<Ts>>...>;
     };
 
   } // namespace internal
diff --git a/include/rfl/internal/strings/join.hpp b/include/rfl/internal/strings/join.hpp
index cc6914a..3b3a7d4 100644
--- a/include/rfl/internal/strings/join.hpp
+++ b/include/rfl/internal/strings/join.hpp
@@ -9,17 +9,13 @@ namespace rfl {
     namespace strings {
 
       /// Joins a string using the delimiter
-      inline std::string join(
-          const std::string&              _delimiter,
-          const std::vector<std::string>& _strings
-      ) {
+      inline std::string
+      join(const std::string& _delimiter, const std::vector<std::string>& _strings) {
         if (_strings.size() == 0) {
           return "";
         }
         auto res = _strings[0];
-        for (size_t i = 1; i < _strings.size(); ++i) {
-          res += _delimiter + _strings[i];
-        }
+        for (size_t i = 1; i < _strings.size(); ++i) { res += _delimiter + _strings[i]; }
         return res;
       }
 
diff --git a/include/rfl/internal/strings/replace_all.hpp b/include/rfl/internal/strings/replace_all.hpp
index 8e001db..bbba4d4 100644
--- a/include/rfl/internal/strings/replace_all.hpp
+++ b/include/rfl/internal/strings/replace_all.hpp
@@ -8,11 +8,8 @@ namespace rfl {
   namespace internal {
     namespace strings {
 
-      inline std::string replace_all(
-          const std::string& _str,
-          const std::string& _from,
-          const std::string& _to
-      ) {
+      inline std::string
+      replace_all(const std::string& _str, const std::string& _from, const std::string& _to) {
         auto str = _str;
 
         size_t pos = 0;
diff --git a/include/rfl/internal/tag_t.hpp b/include/rfl/internal/tag_t.hpp
index 1bd89c9..09efa59 100644
--- a/include/rfl/internal/tag_t.hpp
+++ b/include/rfl/internal/tag_t.hpp
@@ -9,8 +9,7 @@
 namespace rfl::internal {
 
   template <internal::StringLiteral _discriminator, class T>
-  using tag_t = typename std::
-      invoke_result<decltype(make_tag<_discriminator, T>), T>::type;
+  using tag_t = typename std::invoke_result<decltype(make_tag<_discriminator, T>), T>::type;
 
 } // namespace rfl::internal
 
diff --git a/include/rfl/internal/to_flattened_ptr_tuple.hpp b/include/rfl/internal/to_flattened_ptr_tuple.hpp
index 2eb3be3..80d74bb 100644
--- a/include/rfl/internal/to_flattened_ptr_tuple.hpp
+++ b/include/rfl/internal/to_flattened_ptr_tuple.hpp
@@ -15,22 +15,21 @@ namespace rfl {
       constexpr auto i = sizeof...(Args);
       if constexpr (i == 0 && !has_flatten_fields<PtrTuple>()) {
         return std::forward<PtrTuple>(_t);
-      } else if constexpr (i ==
-                           std::tuple_size_v<std::remove_cvref_t<PtrTuple>>) {
+      } else if constexpr (i == std::tuple_size_v<std::remove_cvref_t<PtrTuple>>) {
         return std::tuple_cat(std::forward<Args>(_args)...);
       } else {
         using T = std::tuple_element_t<i, std::remove_cvref_t<PtrTuple>>;
         if constexpr (is_flatten_field_v<T>) {
           return flatten_ptr_tuple(
-              std::forward<PtrTuple>(_t),
-              std::forward<Args>(_args)...,
-              flatten_ptr_tuple(to_ptr_tuple(std::get<i>(_t)->get()))
+            std::forward<PtrTuple>(_t),
+            std::forward<Args>(_args)...,
+            flatten_ptr_tuple(to_ptr_tuple(std::get<i>(_t)->get()))
           );
         } else {
           return flatten_ptr_tuple(
-              std::forward<PtrTuple>(_t),
-              std::forward<Args>(_args)...,
-              std::make_tuple(std::get<i>(_t))
+            std::forward<PtrTuple>(_t),
+            std::forward<Args>(_args)...,
+            std::make_tuple(std::get<i>(_t))
           );
         }
       }
diff --git a/include/rfl/internal/to_ptr_field_tuple.hpp b/include/rfl/internal/to_ptr_field_tuple.hpp
index ccd80bd..aaceccf 100644
--- a/include/rfl/internal/to_ptr_field_tuple.hpp
+++ b/include/rfl/internal/to_ptr_field_tuple.hpp
@@ -29,7 +29,7 @@ namespace rfl {
         return std::tuple();
       } else {
         using FieldNames = field_names_t<T>;
-        auto tup = bind_to_tuple(_t, [](auto& x) { return to_ptr_field(x); });
+        auto tup         = bind_to_tuple(_t, [](auto& x) { return to_ptr_field(x); });
         return wrap_in_fields<FieldNames>(std::move(tup));
       }
     }
diff --git a/include/rfl/internal/to_ptr_named_tuple.hpp b/include/rfl/internal/to_ptr_named_tuple.hpp
index e35274d..e831b2d 100644
--- a/include/rfl/internal/to_ptr_named_tuple.hpp
+++ b/include/rfl/internal/to_ptr_named_tuple.hpp
@@ -22,21 +22,18 @@ namespace rfl {
     template <class PtrFieldTuple, class... Args>
     auto flatten_ptr_field_tuple(PtrFieldTuple& _t, Args&&... _args) {
       constexpr auto i = sizeof...(Args);
-      if constexpr (i ==
-                    std::tuple_size_v<std::remove_cvref_t<PtrFieldTuple>>) {
+      if constexpr (i == std::tuple_size_v<std::remove_cvref_t<PtrFieldTuple>>) {
         return std::tuple_cat(std::forward<Args>(_args)...);
       } else {
         using T = std::tuple_element_t<i, std::remove_cvref_t<PtrFieldTuple>>;
         if constexpr (internal::is_flatten_field<T>::value) {
           auto subtuple = internal::to_ptr_field_tuple(*std::get<i>(_t).get());
           return flatten_ptr_field_tuple(
-              _t,
-              std::forward<Args>(_args)...,
-              flatten_ptr_field_tuple(subtuple)
+            _t, std::forward<Args>(_args)..., flatten_ptr_field_tuple(subtuple)
           );
         } else {
           return flatten_ptr_field_tuple(
-              _t, std::forward<Args>(_args)..., std::make_tuple(std::get<i>(_t))
+            _t, std::forward<Args>(_args)..., std::make_tuple(std::get<i>(_t))
           );
         }
       }
@@ -74,9 +71,7 @@ namespace rfl {
       } else {
         using FieldNames         = rfl::field_names_t<T>;
         auto flattened_ptr_tuple = to_flattened_ptr_tuple(_t);
-        return copy_flattened_tuple_to_named_tuple<FieldNames>(
-            flattened_ptr_tuple
-        );
+        return copy_flattened_tuple_to_named_tuple<FieldNames>(flattened_ptr_tuple);
       }
     }
 
diff --git a/include/rfl/internal/to_std_array.hpp b/include/rfl/internal/to_std_array.hpp
index 7ff2213..763619c 100644
--- a/include/rfl/internal/to_std_array.hpp
+++ b/include/rfl/internal/to_std_array.hpp
@@ -14,9 +14,8 @@ namespace rfl::internal {
 
   template <class T, size_t _n>
   struct StdArrayType<T[_n]> {
-    using Type =
-        std::array<typename StdArrayType<std::remove_cvref_t<T>>::Type, _n>;
-    using ValueType              = std::remove_cvref_t<T>;
+    using Type      = std::array<typename StdArrayType<std::remove_cvref_t<T>>::Type, _n>;
+    using ValueType = std::remove_cvref_t<T>;
     constexpr static size_t size = _n;
   };
 
@@ -27,11 +26,11 @@ namespace rfl::internal {
   auto to_std_array(T&& _t) {
     using Type = std::remove_cvref_t<T>;
     if constexpr (std::is_array_v<Type>) {
-      constexpr size_t n = StdArrayType<Type>::size;
-      const auto fct     = [&]<std::size_t... _i>(std::index_sequence<_i...>) {
-        return to_std_array_t<Type>({to_std_array(
-            std::forward<typename StdArrayType<Type>::ValueType>(_t[_i])
-        )...});
+      constexpr size_t n   = StdArrayType<Type>::size;
+      const auto       fct = [&]<std::size_t... _i>(std::index_sequence<_i...>) {
+        return to_std_array_t<Type>(
+          { to_std_array(std::forward<typename StdArrayType<Type>::ValueType>(_t[_i]))... }
+        );
       };
       return fct(std::make_index_sequence<n>());
     } else {
@@ -43,9 +42,9 @@ namespace rfl::internal {
   auto to_std_array(const T& _t) {
     using Type = std::remove_cvref_t<T>;
     if constexpr (std::is_array_v<Type>) {
-      constexpr size_t n = StdArrayType<Type>::size;
-      const auto fct     = [&]<std::size_t... _i>(std::index_sequence<_i...>) {
-        return to_std_array_t<Type>({to_std_array(_t[_i])...});
+      constexpr size_t n   = StdArrayType<Type>::size;
+      const auto       fct = [&]<std::size_t... _i>(std::index_sequence<_i...>) {
+        return to_std_array_t<Type>({ to_std_array(_t[_i])... });
       };
       return fct(std::make_index_sequence<n>());
     } else {
diff --git a/include/rfl/internal/transform_snake_case.hpp b/include/rfl/internal/transform_snake_case.hpp
index 1c7bb12..06fefa2 100644
--- a/include/rfl/internal/transform_snake_case.hpp
+++ b/include/rfl/internal/transform_snake_case.hpp
@@ -16,11 +16,7 @@ namespace rfl::internal {
   }
 
   /// Transforms the field name from snake case to camel case.
-  template <
-      internal::StringLiteral _name,
-      bool                    _capitalize,
-      size_t                  _i = 0,
-      char... chars>
+  template <internal::StringLiteral _name, bool _capitalize, size_t _i = 0, char... chars>
   consteval auto transform_snake_case() {
     if constexpr (_i == _name.arr_.size()) {
       return StringLiteral<sizeof...(chars) + 1>(chars...);
@@ -29,19 +25,9 @@ namespace rfl::internal {
     } else if constexpr (_name.arr_[_i] == '\0') {
       return transform_snake_case<_name, false, _name.arr_.size(), chars...>();
     } else if constexpr (_capitalize) {
-      return transform_snake_case<
-          _name,
-          false,
-          _i + 1,
-          chars...,
-          to_upper<_name.arr_[_i]>()>();
+      return transform_snake_case<_name, false, _i + 1, chars..., to_upper<_name.arr_[_i]>()>();
     } else {
-      return transform_snake_case<
-          _name,
-          false,
-          _i + 1,
-          chars...,
-          _name.arr_[_i]>();
+      return transform_snake_case<_name, false, _i + 1, chars..., _name.arr_[_i]>();
     }
   }
 } // namespace rfl::internal
diff --git a/include/rfl/internal/wrap_in_fields.hpp b/include/rfl/internal/wrap_in_fields.hpp
index e6508c7..fd69989 100644
--- a/include/rfl/internal/wrap_in_fields.hpp
+++ b/include/rfl/internal/wrap_in_fields.hpp
@@ -13,31 +13,28 @@ namespace rfl {
 
     template <class FieldNames, int j = 0, class... Fields>
     auto wrap_in_fields(auto&& _tuple, Fields&&... _fields) {
-      constexpr auto size =
-          std::tuple_size_v<std::remove_cvref_t<decltype(_tuple)>>;
-      constexpr auto i = sizeof...(_fields);
+      constexpr auto size = std::tuple_size_v<std::remove_cvref_t<decltype(_tuple)>>;
+      constexpr auto i    = sizeof...(_fields);
       if constexpr (i == size) {
         return std::make_tuple(std::move(_fields)...);
       } else {
         auto value = std::move(std::get<i>(_tuple));
-        using Type =
-            std::remove_cvref_t<std::remove_pointer_t<decltype(value)>>;
+        using Type = std::remove_cvref_t<std::remove_pointer_t<decltype(value)>>;
         if constexpr (is_flatten_field_v<Type>) {
           // The problem here is that the FieldNames are already flattened, but
           // this is not, so we need to determine how many field names to skip.
-          constexpr auto n_skip = std::tuple_size_v<
-              std::remove_cvref_t<flattened_ptr_tuple_t<typename Type::Type>>>;
+          constexpr auto n_skip =
+            std::tuple_size_v<std::remove_cvref_t<flattened_ptr_tuple_t<typename Type::Type>>>;
           return wrap_in_fields<FieldNames, j + n_skip>(
-              std::move(_tuple), std::move(_fields)..., std::move(value)
+            std::move(_tuple), std::move(_fields)..., std::move(value)
           );
         } else {
           const auto name_literal = FieldNames::template name_of<j>();
-          auto       new_field    = rfl::make_field<
-                       lit_name_v<std::remove_cvref_t<decltype(name_literal)>>>(
-              std::move(value)
-          );
+          auto       new_field =
+            rfl::make_field<lit_name_v<std::remove_cvref_t<decltype(name_literal)>>>(std::move(value
+            ));
           return wrap_in_fields<FieldNames, j + 1>(
-              std::move(_tuple), std::move(_fields)..., std::move(new_field)
+            std::move(_tuple), std::move(_fields)..., std::move(new_field)
           );
         }
       }
diff --git a/include/rfl/io/load_string.hpp b/include/rfl/io/load_string.hpp
index a3cddb8..e2116e8 100644
--- a/include/rfl/io/load_string.hpp
+++ b/include/rfl/io/load_string.hpp
@@ -13,16 +13,12 @@ namespace rfl {
     inline Result<std::string> load_string(const std::string& _fname) {
       std::ifstream infile(_fname);
       if (infile.is_open()) {
-        auto r = std::string(
-            std::istreambuf_iterator<char>(infile),
-            std::istreambuf_iterator<char>()
-        );
+        auto r =
+          std::string(std::istreambuf_iterator<char>(infile), std::istreambuf_iterator<char>());
         infile.close();
         return r;
       } else {
-        return Error(
-            "Unable to open file '" + _fname + "' or file could not be found."
-        );
+        return Error("Unable to open file '" + _fname + "' or file could not be found.");
       }
     }
 
diff --git a/include/rfl/io/save_bytes.hpp b/include/rfl/io/save_bytes.hpp
index 3361e5a..bffdeda 100644
--- a/include/rfl/io/save_bytes.hpp
+++ b/include/rfl/io/save_bytes.hpp
@@ -12,11 +12,8 @@ namespace rfl {
   namespace io {
 
     template <class T, class WriteFunction>
-    Result<Nothing> save_bytes(
-        const std::string&   _fname,
-        const T&             _obj,
-        const WriteFunction& _write
-    ) {
+    Result<Nothing>
+    save_bytes(const std::string& _fname, const T& _obj, const WriteFunction& _write) {
       try {
         std::ofstream output(_fname, std::ios::out | std::ios::binary);
         _write(_obj, output);
diff --git a/include/rfl/io/save_string.hpp b/include/rfl/io/save_string.hpp
index 672d386..4f49cc7 100644
--- a/include/rfl/io/save_string.hpp
+++ b/include/rfl/io/save_string.hpp
@@ -11,11 +11,8 @@ namespace rfl {
   namespace io {
 
     template <class T, class WriteFunction>
-    Result<Nothing> save_string(
-        const std::string&   _fname,
-        const T&             _obj,
-        const WriteFunction& _write
-    ) {
+    Result<Nothing>
+    save_string(const std::string& _fname, const T& _obj, const WriteFunction& _write) {
       try {
         std::ofstream outfile;
         outfile.open(_fname);
diff --git a/include/rfl/json/Reader.hpp b/include/rfl/json/Reader.hpp
index 5295c14..09028e5 100644
--- a/include/rfl/json/Reader.hpp
+++ b/include/rfl/json/Reader.hpp
@@ -44,12 +44,10 @@ namespace rfl {
 
       template <class T>
       static constexpr bool has_custom_constructor =
-          (requires(InputVarType var) { T::from_json_obj(var); });
+        (requires(InputVarType var) { T::from_json_obj(var); });
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&    _name,
-          const InputObjectType _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType _obj)
+        const noexcept {
         const auto var = InputVarType(yyjson_obj_get(_obj.val_, _name.c_str()));
         if (!var.val_) {
           return rfl::Error("Object contains no field named '" + _name + "'.");
@@ -62,10 +60,8 @@ namespace rfl {
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         yyjson_val*     val;
         yyjson_arr_iter iter;
         yyjson_arr_iter_init(_arr.val_, &iter);
@@ -79,10 +75,8 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
         yyjson_obj_iter iter;
         yyjson_obj_iter_init(_obj.val_, &iter);
         yyjson_val* key;
@@ -126,16 +120,14 @@ namespace rfl {
         }
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType _var
-      ) const noexcept {
+      rfl::Result<InputArrayType> to_array(const InputVarType _var) const noexcept {
         if (!yyjson_is_arr(_var.val_)) {
           return rfl::Error("Could not cast to array!");
         }
         return InputArrayType(_var.val_);
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType _var
-      ) const noexcept {
+      rfl::Result<InputObjectType> to_object(const InputVarType _var) const noexcept {
         if (!yyjson_is_obj(_var.val_)) {
           return rfl::Error("Could not cast to object!");
         }
@@ -143,8 +135,7 @@ namespace rfl {
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType _var) const noexcept {
         try {
           return T::from_json_obj(_var);
         } catch (std::exception& e) { return rfl::Error(e.what()); }
diff --git a/include/rfl/json/Writer.hpp b/include/rfl/json/Writer.hpp
index e7177a8..023a6c0 100644
--- a/include/rfl/json/Writer.hpp
+++ b/include/rfl/json/Writer.hpp
@@ -72,51 +72,42 @@ namespace rfl {
         return OutputVarType(val);
       }
 
-      OutputArrayType add_array_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         const auto arr = yyjson_mut_arr(doc_);
         yyjson_mut_arr_add_val(_parent->val_, arr);
         return OutputArrayType(arr);
       }
 
       OutputArrayType add_array_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         const auto arr = yyjson_mut_arr(doc_);
-        yyjson_mut_obj_add(
-            _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), arr
-        );
+        yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), arr);
         return OutputArrayType(arr);
       }
 
-      OutputObjectType add_object_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         const auto obj = yyjson_mut_obj(doc_);
         yyjson_mut_arr_add_val(_parent->val_, obj);
         return OutputObjectType(obj);
       }
 
       OutputObjectType add_object_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         const auto obj = yyjson_mut_obj(doc_);
-        yyjson_mut_obj_add(
-            _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), obj
-        );
+        yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), obj);
         return OutputObjectType(obj);
       }
 
       template <class T>
-      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-          const noexcept {
+      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
         const auto val = from_basic_type(_var);
         yyjson_mut_arr_add_val(_parent->val_, val.val_);
         return OutputVarType(val);
@@ -124,14 +115,12 @@ namespace rfl {
 
       template <class T>
       OutputVarType add_value_to_object(
-          const std::string_view& _name,
-          const T&                _var,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const T&                _var,
+        OutputObjectType*       _parent
       ) const noexcept {
         const auto val = from_basic_type(_var);
-        yyjson_mut_obj_add(
-            _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), val.val_
-        );
+        yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), val.val_);
         return OutputVarType(val);
       }
 
@@ -141,14 +130,10 @@ namespace rfl {
         return OutputVarType(null);
       }
 
-      OutputVarType add_null_to_object(
-          const std::string_view& _name,
-          OutputObjectType*       _parent
-      ) const noexcept {
+      OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+        const noexcept {
         const auto null = yyjson_mut_null(doc_);
-        yyjson_mut_obj_add(
-            _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), null
-        );
+        yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), null);
         return OutputVarType(null);
       }
 
@@ -164,15 +149,11 @@ namespace rfl {
         } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
           return OutputVarType(yyjson_mut_bool(doc_, _var));
         } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
-          return OutputVarType(yyjson_mut_real(doc_, static_cast<double>(_var))
-          );
+          return OutputVarType(yyjson_mut_real(doc_, static_cast<double>(_var)));
         } else if constexpr (std::is_unsigned<std::remove_cvref_t<T>>()) {
-          return OutputVarType(
-              yyjson_mut_uint(doc_, static_cast<uint64_t>(_var))
-          );
+          return OutputVarType(yyjson_mut_uint(doc_, static_cast<uint64_t>(_var)));
         } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
-          return OutputVarType(yyjson_mut_int(doc_, static_cast<int64_t>(_var))
-          );
+          return OutputVarType(yyjson_mut_int(doc_, static_cast<int64_t>(_var)));
         } else {
           static_assert(rfl::always_false_v<T>, "Unsupported type.");
         }
diff --git a/include/rfl/json/load.hpp b/include/rfl/json/load.hpp
index fabba8b..e3a78fd 100644
--- a/include/rfl/json/load.hpp
+++ b/include/rfl/json/load.hpp
@@ -10,9 +10,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_string = [](const auto& _str) {
-        return read<T, Ps...>(_str);
-      };
+      const auto read_string = [](const auto& _str) { return read<T, Ps...>(_str); };
       return rfl::io::load_string(_fname).and_then(read_string);
     }
 
diff --git a/include/rfl/json/read.hpp b/include/rfl/json/read.hpp
index 0cbb1a0..2026ab9 100644
--- a/include/rfl/json/read.hpp
+++ b/include/rfl/json/read.hpp
@@ -25,15 +25,14 @@ namespace rfl {
 
     /// Parses an object from JSON using reflection.
     template <class T, class... Ps>
-    Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _json_str
-    ) {
+    Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _json_str) {
       yyjson_doc* doc = yyjson_read(_json_str.c_str(), _json_str.size(), 0);
       if (!doc) {
         return Error("Could not parse document");
       }
       yyjson_val* root = yyjson_doc_get_root(doc);
       const auto  r    = Reader();
-      auto res = Parser<T, Processors<Ps...>>::read(r, InputVarType(root));
+      auto        res  = Parser<T, Processors<Ps...>>::read(r, InputVarType(root));
       yyjson_doc_free(doc);
       return res;
     }
@@ -41,10 +40,8 @@ namespace rfl {
     /// Parses an object from a stringstream.
     template <class T, class... Ps>
     auto read(std::istream& _stream) {
-      const auto json_str = std::string(
-          std::istreambuf_iterator<char>(_stream),
-          std::istreambuf_iterator<char>()
-      );
+      const auto json_str =
+        std::string(std::istreambuf_iterator<char>(_stream), std::istreambuf_iterator<char>());
       return read<T, Ps...>(json_str);
     }
 
diff --git a/include/rfl/json/save.hpp b/include/rfl/json/save.hpp
index c6637d1..0ce7f01 100644
--- a/include/rfl/json/save.hpp
+++ b/include/rfl/json/save.hpp
@@ -14,13 +14,9 @@ namespace rfl {
   namespace json {
 
     template <class... Ps>
-    Result<Nothing> save(
-        const std::string&      _fname,
-        const auto&             _obj,
-        const yyjson_write_flag _flag = 0
-    ) {
-      const auto write_func =
-          [_flag](const auto& _obj, auto& _stream) -> auto& {
+    Result<Nothing>
+    save(const std::string& _fname, const auto& _obj, const yyjson_write_flag _flag = 0) {
+      const auto write_func = [_flag](const auto& _obj, auto& _stream) -> auto& {
         return write<Ps...>(_obj, _stream, _flag);
       };
       return rfl::io::save_string(_fname, _obj, write_func);
diff --git a/include/rfl/json/schema/JSONSchema.hpp b/include/rfl/json/schema/JSONSchema.hpp
index ec67d20..03b508e 100644
--- a/include/rfl/json/schema/JSONSchema.hpp
+++ b/include/rfl/json/schema/JSONSchema.hpp
@@ -14,10 +14,9 @@ namespace rfl::json::schema {
 
   template <class T>
   struct JSONSchema {
-    Rename<"$schema", Literal<"https://json-schema.org/draft/2020-12/schema">>
-                                schema;
-    Flatten<T>                  root;
-    std::map<std::string, Type> definitions;
+    Rename<"$schema", Literal<"https://json-schema.org/draft/2020-12/schema">> schema;
+    Flatten<T>                                                                 root;
+    std::map<std::string, Type>                                                definitions;
   };
 
 } // namespace rfl::json::schema
diff --git a/include/rfl/json/schema/Type.hpp b/include/rfl/json/schema/Type.hpp
index 72dffd5..3486bef 100644
--- a/include/rfl/json/schema/Type.hpp
+++ b/include/rfl/json/schema/Type.hpp
@@ -132,26 +132,26 @@ namespace rfl::json::schema {
     };
 
     using ReflectionType = std::variant<
-        AllOf,
-        AnyOf,
-        Boolean,
-        ExclusiveMaximum,
-        ExclusiveMinimum,
-        FixedSizeTypedArray,
-        Integer,
-        Maximum,
-        Minimum,
-        Number,
-        Null,
-        Object,
-        OneOf,
-        Reference,
-        Regex,
-        String,
-        StringEnum,
-        StringMap,
-        Tuple,
-        TypedArray>;
+      AllOf,
+      AnyOf,
+      Boolean,
+      ExclusiveMaximum,
+      ExclusiveMinimum,
+      FixedSizeTypedArray,
+      Integer,
+      Maximum,
+      Minimum,
+      Number,
+      Null,
+      Object,
+      OneOf,
+      Reference,
+      Regex,
+      String,
+      StringEnum,
+      StringMap,
+      Tuple,
+      TypedArray>;
 
     const auto& reflection() const { return value; }
 
diff --git a/include/rfl/json/to_schema.hpp b/include/rfl/json/to_schema.hpp
index 46a692f..c0c94e1 100644
--- a/include/rfl/json/to_schema.hpp
+++ b/include/rfl/json/to_schema.hpp
@@ -20,9 +20,7 @@
 
 namespace rfl::json {
 
-  inline schema::Type type_to_json_schema_type(
-      const parsing::schema::Type& _type
-  );
+  inline schema::Type type_to_json_schema_type(const parsing::schema::Type& _type);
 
   inline bool is_optional(const parsing::schema::Type& _t) {
     const auto handle = [](const auto& _v) -> bool {
@@ -32,15 +30,12 @@ namespace rfl::json {
     return std::visit(handle, _t.variant_);
   }
 
-  inline std::string numeric_type_to_string(const parsing::schema::Type& _type
-  ) {
+  inline std::string numeric_type_to_string(const parsing::schema::Type& _type) {
     const auto handle_variant = [](const auto& _t) -> std::string {
       using T    = std::remove_cvref_t<decltype(_t)>;
       using Type = parsing::schema::Type;
-      if constexpr (std::is_same<T, Type::Int32>() ||
-                    std::is_same<T, Type::Int64>() ||
-                    std::is_same<T, Type::UInt32>() ||
-                    std::is_same<T, Type::UInt64>() ||
+      if constexpr (std::is_same<T, Type::Int32>() || std::is_same<T, Type::Int64>() ||
+                    std::is_same<T, Type::UInt32>() || std::is_same<T, Type::UInt64>() ||
                     std::is_same<T, Type::Integer>()) {
         return schema::Type::Integer {}.type.str();
       } else {
@@ -51,112 +46,79 @@ namespace rfl::json {
   }
 
   inline schema::Type handle_validation_type(
-      const parsing::schema::Type&           _type,
-      const parsing::schema::ValidationType& _validation_type
+    const parsing::schema::Type&           _type,
+    const parsing::schema::ValidationType& _validation_type
   ) {
     const auto handle_variant = [&](const auto& _v) -> schema::Type {
       using T              = std::remove_cvref_t<decltype(_v)>;
       using ValidationType = parsing::schema::ValidationType;
       if constexpr (std::is_same<T, ValidationType::AllOf>()) {
         auto all_of = std::vector<schema::Type>();
-        for (const auto& t : _v.types_) {
-          all_of.emplace_back(handle_validation_type(_type, t));
-        }
-        return schema::Type {.value = schema::Type::AllOf {.allOf = all_of}};
+        for (const auto& t : _v.types_) { all_of.emplace_back(handle_validation_type(_type, t)); }
+        return schema::Type { .value = schema::Type::AllOf { .allOf = all_of } };
 
       } else if constexpr (std::is_same<T, ValidationType::AnyOf>()) {
         auto any_of = std::vector<schema::Type>();
-        for (const auto& t : _v.types_) {
-          any_of.emplace_back(handle_validation_type(_type, t));
-        }
-        return schema::Type {.value = schema::Type::AnyOf {.anyOf = any_of}};
+        for (const auto& t : _v.types_) { any_of.emplace_back(handle_validation_type(_type, t)); }
+        return schema::Type { .value = schema::Type::AnyOf { .anyOf = any_of } };
 
       } else if constexpr (std::is_same<T, ValidationType::OneOf>()) {
         auto one_of = std::vector<schema::Type>();
-        for (const auto& t : _v.types_) {
-          one_of.emplace_back(handle_validation_type(_type, t));
-        }
-        return schema::Type {.value = schema::Type::OneOf {.oneOf = one_of}};
+        for (const auto& t : _v.types_) { one_of.emplace_back(handle_validation_type(_type, t)); }
+        return schema::Type { .value = schema::Type::OneOf { .oneOf = one_of } };
 
       } else if constexpr (std::is_same<T, ValidationType::Regex>()) {
-        return schema::Type {
-            .value = schema::Type::Regex {.pattern = _v.pattern_}
-        };
+        return schema::Type { .value = schema::Type::Regex { .pattern = _v.pattern_ } };
 
       } else if constexpr (std::is_same<T, ValidationType::Size>()) {
         return type_to_json_schema_type(_type);
 
-      } else if constexpr (std::is_same<T, ValidationType::ExclusiveMaximum>(
-                           )) {
+      } else if constexpr (std::is_same<T, ValidationType::ExclusiveMaximum>()) {
         return schema::Type {
-            .value =
-                schema::Type::ExclusiveMaximum {
-                                                .exclusiveMaximum = _v.value_,
-                                                .type             = numeric_type_to_string(_type)
-                }
+          .value = schema::Type::ExclusiveMaximum { .exclusiveMaximum = _v.value_,
+                                                   .type = numeric_type_to_string(_type) }
         };
 
-      } else if constexpr (std::is_same<T, ValidationType::ExclusiveMinimum>(
-                           )) {
+      } else if constexpr (std::is_same<T, ValidationType::ExclusiveMinimum>()) {
         return schema::Type {
-            .value =
-                schema::Type::ExclusiveMinimum {
-                                                .exclusiveMinimum = _v.value_,
-                                                .type             = numeric_type_to_string(_type)
-                }
+          .value = schema::Type::ExclusiveMinimum { .exclusiveMinimum = _v.value_,
+                                                   .type = numeric_type_to_string(_type) }
         };
 
       } else if constexpr (std::is_same<T, ValidationType::Maximum>()) {
         return schema::Type {
-            .value =
-                schema::Type::Maximum {
-                                       .maximum = _v.value_, .type = numeric_type_to_string(_type)
-                }
+          .value =
+            schema::Type::Maximum { .maximum = _v.value_, .type = numeric_type_to_string(_type) }
         };
 
       } else if constexpr (std::is_same<T, ValidationType::Minimum>()) {
         return schema::Type {
-            .value =
-                schema::Type::Minimum {
-                                       .minimum = _v.value_, .type = numeric_type_to_string(_type)
-                }
+          .value =
+            schema::Type::Minimum { .minimum = _v.value_, .type = numeric_type_to_string(_type) }
         };
 
       } else if constexpr (std::is_same<T, ValidationType::EqualTo>()) {
         const auto maximum = schema::Type {
-            .value =
-                schema::Type::Maximum {
-                                       .maximum = _v.value_, .type = numeric_type_to_string(_type)
-                }
+          .value =
+            schema::Type::Maximum { .maximum = _v.value_, .type = numeric_type_to_string(_type) }
         };
         const auto minimum = schema::Type {
-            .value =
-                schema::Type::Minimum {
-                                       .minimum = _v.value_, .type = numeric_type_to_string(_type)
-                }
-        };
-        return schema::Type {
-            .value = schema::Type::AllOf {.allOf = {maximum, minimum}}
+          .value =
+            schema::Type::Minimum { .minimum = _v.value_, .type = numeric_type_to_string(_type) }
         };
+        return schema::Type { .value = schema::Type::AllOf { .allOf = { maximum, minimum } } };
 
       } else if constexpr (std::is_same<T, ValidationType::NotEqualTo>()) {
         const auto excl_maximum = schema::Type {
-            .value =
-                schema::Type::ExclusiveMaximum {
-                                                .exclusiveMaximum = _v.value_,
-                                                .type             = numeric_type_to_string(_type)
-                }
+          .value = schema::Type::ExclusiveMaximum { .exclusiveMaximum = _v.value_,
+                                                   .type = numeric_type_to_string(_type) }
         };
         const auto excl_minimum = schema::Type {
-            .value =
-                schema::Type::ExclusiveMinimum {
-                                                .exclusiveMinimum = _v.value_,
-                                                .type             = numeric_type_to_string(_type)
-                }
-        };
-        return schema::Type {
-            .value = schema::Type::AnyOf {.anyOf = {excl_maximum, excl_minimum}}
+          .value = schema::Type::ExclusiveMinimum { .exclusiveMinimum = _v.value_,
+                                                   .type = numeric_type_to_string(_type) }
         };
+        return schema::Type { .value =
+                                schema::Type::AnyOf { .anyOf = { excl_maximum, excl_minimum } } };
 
       } else {
         static_assert(rfl::always_false_v<T>, "Not all cases were covered.");
@@ -166,59 +128,48 @@ namespace rfl::json {
     return std::visit(handle_variant, _validation_type.variant_);
   }
 
-  inline schema::Type type_to_json_schema_type(
-      const parsing::schema::Type& _type
-  ) {
+  inline schema::Type type_to_json_schema_type(const parsing::schema::Type& _type) {
     const auto handle_variant = [](const auto& _t) -> schema::Type {
       using T    = std::remove_cvref_t<decltype(_t)>;
       using Type = parsing::schema::Type;
       if constexpr (std::is_same<T, Type::Boolean>()) {
-        return schema::Type {.value = schema::Type::Boolean {}};
+        return schema::Type { .value = schema::Type::Boolean {} };
 
-      } else if constexpr (std::is_same<T, Type::Int32>() ||
-                           std::is_same<T, Type::Int64>() ||
-                           std::is_same<T, Type::UInt32>() ||
-                           std::is_same<T, Type::UInt64>() ||
+      } else if constexpr (std::is_same<T, Type::Int32>() || std::is_same<T, Type::Int64>() ||
+                           std::is_same<T, Type::UInt32>() || std::is_same<T, Type::UInt64>() ||
                            std::is_same<T, Type::Integer>()) {
-        return schema::Type {.value = schema::Type::Integer {}};
+        return schema::Type { .value = schema::Type::Integer {} };
 
-      } else if constexpr (std::is_same<T, Type::Float>() ||
-                           std::is_same<T, Type::Double>()) {
-        return schema::Type {.value = schema::Type::Number {}};
+      } else if constexpr (std::is_same<T, Type::Float>() || std::is_same<T, Type::Double>()) {
+        return schema::Type { .value = schema::Type::Number {} };
 
       } else if constexpr (std::is_same<T, Type::String>()) {
-        return schema::Type {.value = schema::Type::String {}};
+        return schema::Type { .value = schema::Type::String {} };
 
       } else if constexpr (std::is_same<T, Type::AnyOf>()) {
         auto any_of = std::vector<schema::Type>();
-        for (const auto& t : _t.types_) {
-          any_of.emplace_back(type_to_json_schema_type(t));
-        }
-        return schema::Type {.value = schema::Type::AnyOf {.anyOf = any_of}};
+        for (const auto& t : _t.types_) { any_of.emplace_back(type_to_json_schema_type(t)); }
+        return schema::Type { .value = schema::Type::AnyOf { .anyOf = any_of } };
 
       } else if constexpr (std::is_same<T, Type::Description>()) {
         auto       res               = type_to_json_schema_type(*_t.type_);
         const auto update_prediction = [&](auto _v) -> schema::Type {
           _v.description = _t.description_;
-          return schema::Type {_v};
+          return schema::Type { _v };
         };
         return std::visit(update_prediction, res.value);
 
       } else if constexpr (std::is_same<T, Type::FixedSizeTypedArray>()) {
         return schema::Type {
-            .value =
-                schema::Type::FixedSizeTypedArray {
-                                                   .items = Ref<schema::Type>::make(
-                        type_to_json_schema_type(*_t.type_)
-                    ), .minContains = _t.size_,
-                                                   .maxContains = _t.size_
-                }
+          .value =
+            schema::Type::FixedSizeTypedArray {
+                                               .items       = Ref<schema::Type>::make(type_to_json_schema_type(*_t.type_)),
+                                               .minContains = _t.size_,
+                                               .maxContains = _t.size_ }
         };
 
       } else if constexpr (std::is_same<T, Type::Literal>()) {
-        return schema::Type {
-            .value = schema::Type::StringEnum {.values = _t.values_}
-        };
+        return schema::Type { .value = schema::Type::StringEnum { .values = _t.values_ } };
 
       } else if constexpr (std::is_same<T, Type::Object>()) {
         auto properties = std::map<std::string, schema::Type>();
@@ -230,56 +181,33 @@ namespace rfl::json {
           }
         }
         return schema::Type {
-            .value =
-                schema::Type::Object {
-                                      .properties = properties, .required = required
-                }
+          .value = schema::Type::Object { .properties = properties, .required = required }
         };
 
       } else if constexpr (std::is_same<T, Type::Optional>()) {
-        return schema::Type {
-            .value =
-                schema::Type::AnyOf {
-                    .anyOf =
-                        {type_to_json_schema_type(*_t.type_),
-                         schema::Type {schema::Type::Null {}}}
-                }
-        };
+        return schema::Type { .value = schema::Type::AnyOf {
+                                .anyOf = { type_to_json_schema_type(*_t.type_),
+                                           schema::Type { schema::Type::Null {} } } } };
 
       } else if constexpr (std::is_same<T, Type::Reference>()) {
-        return schema::Type {
-            .value =
-                schema::Type::Reference {.ref = "#/definitions/" + _t.name_}
-        };
+        return schema::Type { .value =
+                                schema::Type::Reference { .ref = "#/definitions/" + _t.name_ } };
 
       } else if constexpr (std::is_same<T, Type::StringMap>()) {
-        return schema::Type {
-            .value =
-                schema::Type::StringMap {
-                    .additionalProperties = Ref<schema::Type>::make(
-                        type_to_json_schema_type(*_t.value_type_)
-                    )
-                }
-        };
+        return schema::Type { .value = schema::Type::StringMap {
+                                .additionalProperties =
+                                  Ref<schema::Type>::make(type_to_json_schema_type(*_t.value_type_)
+                                  ) } };
 
       } else if constexpr (std::is_same<T, Type::Tuple>()) {
         auto items = std::vector<schema::Type>();
-        for (const auto& t : _t.types_) {
-          items.emplace_back(type_to_json_schema_type(t));
-        }
-        return schema::Type {
-            .value = schema::Type::Tuple {.prefixItems = items}
-        };
+        for (const auto& t : _t.types_) { items.emplace_back(type_to_json_schema_type(t)); }
+        return schema::Type { .value = schema::Type::Tuple { .prefixItems = items } };
 
       } else if constexpr (std::is_same<T, Type::TypedArray>()) {
-        return schema::Type {
-            .value =
-                schema::Type::TypedArray {
-                    .items = Ref<schema::Type>::make(
-                        type_to_json_schema_type(*_t.type_)
-                    )
-                }
-        };
+        return schema::Type { .value = schema::Type::TypedArray {
+                                .items =
+                                  Ref<schema::Type>::make(type_to_json_schema_type(*_t.type_)) } };
 
       } else if constexpr (std::is_same<T, Type::Validated>()) {
         return handle_validation_type(*_t.type_, _t.validation_);
@@ -303,19 +231,15 @@ namespace rfl::json {
   /// Returns the JSON schema for a class.
   template <class T, class... Ps>
   std::string to_schema(const yyjson_write_flag _flag = 0) {
-    const auto internal_schema =
-        parsing::schema::make<Reader, Writer, T, Processors<Ps...>>();
-    auto definitions = std::map<std::string, schema::Type>();
+    const auto internal_schema = parsing::schema::make<Reader, Writer, T, Processors<Ps...>>();
+    auto       definitions     = std::map<std::string, schema::Type>();
     for (const auto& [k, v] : internal_schema.definitions_) {
       definitions[k] = type_to_json_schema_type(v);
     }
-    using JSONSchemaType =
-        typename TypeHelper<schema::Type::ReflectionType>::JSONSchemaType;
+    using JSONSchemaType = typename TypeHelper<schema::Type::ReflectionType>::JSONSchemaType;
     const auto to_schema = [&](auto&& _root) -> JSONSchemaType {
       using U = std::decay_t<decltype(_root)>;
-      return schema::JSONSchema<U> {
-          .root = std::move(_root), .definitions = definitions
-      };
+      return schema::JSONSchema<U> { .root = std::move(_root), .definitions = definitions };
     };
     auto       root        = type_to_json_schema_type(internal_schema.root_);
     const auto json_schema = std::visit(to_schema, std::move(root.value));
diff --git a/include/rfl/json/write.hpp b/include/rfl/json/write.hpp
index d79f296..31b5ef7 100644
--- a/include/rfl/json/write.hpp
+++ b/include/rfl/json/write.hpp
@@ -22,9 +22,7 @@ namespace rfl {
       using T          = std::remove_cvref_t<decltype(_obj)>;
       using ParentType = parsing::Parent<Writer>;
       auto w           = Writer(yyjson_mut_doc_new(NULL));
-      Parser<T, Processors<Ps...>>::write(
-          w, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root {});
       const char* json_c_str = yyjson_mut_write(w.doc_, _flag, NULL);
       const auto  json_str   = std::string(json_c_str);
       free((void*)json_c_str);
@@ -34,17 +32,12 @@ namespace rfl {
 
     /// Writes a JSON into an ostream.
     template <class... Ps>
-    std::ostream& write(
-        const auto&             _obj,
-        std::ostream&           _stream,
-        const yyjson_write_flag _flag = 0
-    ) {
+    std::ostream&
+    write(const auto& _obj, std::ostream& _stream, const yyjson_write_flag _flag = 0) {
       using T          = std::remove_cvref_t<decltype(_obj)>;
       using ParentType = parsing::Parent<Writer>;
       auto w           = Writer(yyjson_mut_doc_new(NULL));
-      Parser<T, Processors<Ps...>>::write(
-          w, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root {});
       const char* json_c_str = yyjson_mut_write(w.doc_, _flag, NULL);
       _stream << json_c_str;
       free((void*)json_c_str);
diff --git a/include/rfl/make_named_tuple.hpp b/include/rfl/make_named_tuple.hpp
index bf1373e..c415ba9 100644
--- a/include/rfl/make_named_tuple.hpp
+++ b/include/rfl/make_named_tuple.hpp
@@ -11,9 +11,7 @@ namespace rfl {
   /// to explitly define the field types.
   template <class... FieldTypes>
   inline auto make_named_tuple(FieldTypes&&... _args) {
-    return NamedTuple<std::remove_cvref_t<FieldTypes>...>(
-        std::forward<FieldTypes>(_args)...
-    );
+    return NamedTuple<std::remove_cvref_t<FieldTypes>...>(std::forward<FieldTypes>(_args)...);
   }
 
   /// Convenience constructor that doesn't require you
diff --git a/include/rfl/msgpack/Parser.hpp b/include/rfl/msgpack/Parser.hpp
index e8d679b..96deeb2 100644
--- a/include/rfl/msgpack/Parser.hpp
+++ b/include/rfl/msgpack/Parser.hpp
@@ -12,40 +12,26 @@ namespace rfl {
     /// Because of that, we require all of the fields and then set them to
     /// nullptr, if necessary.
     template <class ProcessorsType, class... FieldTypes>
-      requires AreReaderAndWriter<
+      requires AreReaderAndWriter<msgpack::Reader, msgpack::Writer, NamedTuple<FieldTypes...>>
+    struct Parser<msgpack::Reader, msgpack::Writer, NamedTuple<FieldTypes...>, ProcessorsType>
+      : public NamedTupleParser<
           msgpack::Reader,
           msgpack::Writer,
-          NamedTuple<FieldTypes...>>
-    struct Parser<
-        msgpack::Reader,
-        msgpack::Writer,
-        NamedTuple<FieldTypes...>,
-        ProcessorsType>
-        : public NamedTupleParser<
-              msgpack::Reader,
-              msgpack::Writer,
-              /*_ignore_empty_containers=*/false,
-              /*_all_required=*/true,
-              ProcessorsType,
-              FieldTypes...> {};
+          /*_ignore_empty_containers=*/false,
+          /*_all_required=*/true,
+          ProcessorsType,
+          FieldTypes...> {};
 
     template <class ProcessorsType, class... Ts>
-      requires AreReaderAndWriter<
+      requires AreReaderAndWriter<msgpack::Reader, msgpack::Writer, std::tuple<Ts...>>
+    struct Parser<msgpack::Reader, msgpack::Writer, std::tuple<Ts...>, ProcessorsType>
+      : public TupleParser<
           msgpack::Reader,
           msgpack::Writer,
-          std::tuple<Ts...>>
-    struct Parser<
-        msgpack::Reader,
-        msgpack::Writer,
-        std::tuple<Ts...>,
-        ProcessorsType>
-        : public TupleParser<
-              msgpack::Reader,
-              msgpack::Writer,
-              /*_ignore_empty_containers=*/false,
-              /*_all_required=*/true,
-              ProcessorsType,
-              Ts...> {};
+          /*_ignore_empty_containers=*/false,
+          /*_all_required=*/true,
+          ProcessorsType,
+          Ts...> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/msgpack/Reader.hpp b/include/rfl/msgpack/Reader.hpp
index 65615e9..fb21a4d 100644
--- a/include/rfl/msgpack/Reader.hpp
+++ b/include/rfl/msgpack/Reader.hpp
@@ -30,21 +30,16 @@ namespace rfl {
 
       template <class T>
       static constexpr bool has_custom_constructor =
-          (requires(InputVarType var) { T::from_msgpack_obj(var); });
+        (requires(InputVarType var) { T::from_msgpack_obj(var); });
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&     _name,
-          const InputObjectType& _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType& _obj)
+        const noexcept {
         for (uint32_t i = 0; i < _obj.size; ++i) {
           const auto& key = _obj.ptr[i].key;
           if (key.type != MSGPACK_OBJECT_STR) {
-            return Error(
-                "Key in element " + std::to_string(i) + " was not a string."
-            );
+            return Error("Key in element " + std::to_string(i) + " was not a string.");
           }
-          const auto current_name =
-              std::string_view(key.via.str.ptr, key.via.str.size);
+          const auto current_name = std::string_view(key.via.str.ptr, key.via.str.size);
           if (_name == current_name) {
             return _obj.ptr[i].val;
           }
@@ -72,8 +67,8 @@ namespace rfl {
           return _var.via.boolean;
         } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
                              std::is_integral<std::remove_cvref_t<T>>()) {
-          if (type == MSGPACK_OBJECT_FLOAT32 ||
-              type == MSGPACK_OBJECT_FLOAT64 || type == MSGPACK_OBJECT_FLOAT) {
+          if (type == MSGPACK_OBJECT_FLOAT32 || type == MSGPACK_OBJECT_FLOAT64 ||
+              type == MSGPACK_OBJECT_FLOAT) {
             return static_cast<T>(_var.via.f64);
           } else if (type == MSGPACK_OBJECT_POSITIVE_INTEGER) {
             return static_cast<T>(_var.via.u64);
@@ -81,25 +76,23 @@ namespace rfl {
             return static_cast<T>(_var.via.i64);
           }
           return rfl::Error(
-              "Could not cast to numeric value. The type must be integral, "
-              "float "
-              "or double."
+            "Could not cast to numeric value. The type must be integral, "
+            "float "
+            "or double."
           );
         } else {
           static_assert(rfl::always_false_v<T>, "Unsupported type.");
         }
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputArrayType> to_array(const InputVarType& _var) const noexcept {
         if (_var.type != MSGPACK_OBJECT_ARRAY) {
           return Error("Could not cast to an array.");
         }
         return _var.via.array;
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputObjectType> to_object(const InputVarType& _var) const noexcept {
         if (_var.type != MSGPACK_OBJECT_MAP) {
           return Error("Could not cast to a map.");
         }
@@ -107,10 +100,8 @@ namespace rfl {
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         for (uint32_t i = 0; i < _arr.size; ++i) {
           const auto err = _array_reader.read(_arr.ptr[i]);
           if (err) {
@@ -121,17 +112,13 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
         for (uint32_t i = 0; i < _obj.size; ++i) {
           const auto& key = _obj.ptr[i].key;
           const auto& val = _obj.ptr[i].val;
           if (key.type != MSGPACK_OBJECT_STR) {
-            return Error(
-                "Key in element " + std::to_string(i) + " was not a string."
-            );
+            return Error("Key in element " + std::to_string(i) + " was not a string.");
           }
           const auto name = std::string_view(key.via.str.ptr, key.via.str.size);
           _object_reader.read(name, val);
@@ -140,8 +127,7 @@ namespace rfl {
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType& _var) const noexcept {
         try {
           return T::from_msgpack_obj(_var);
         } catch (std::exception& e) { return rfl::Error(e.what()); }
diff --git a/include/rfl/msgpack/Writer.hpp b/include/rfl/msgpack/Writer.hpp
index 4813369..ab6be7d 100644
--- a/include/rfl/msgpack/Writer.hpp
+++ b/include/rfl/msgpack/Writer.hpp
@@ -35,13 +35,9 @@ namespace rfl::msgpack {
 
     ~Writer() = default;
 
-    OutputArrayType array_as_root(const size_t _size) const noexcept {
-      return new_array(_size);
-    }
+    OutputArrayType array_as_root(const size_t _size) const noexcept { return new_array(_size); }
 
-    OutputObjectType object_as_root(const size_t _size) const noexcept {
-      return new_object(_size);
-    }
+    OutputObjectType object_as_root(const size_t _size) const noexcept { return new_object(_size); }
 
     OutputVarType null_as_root() const noexcept {
       msgpack_pack_nil(pk_);
@@ -53,34 +49,30 @@ namespace rfl::msgpack {
       return new_value(_var);
     }
 
-    OutputArrayType add_array_to_array(
-        const size_t     _size,
-        OutputArrayType* _parent
-    ) const noexcept {
+    OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+      const noexcept {
       return new_array(_size);
     }
 
     OutputArrayType add_array_to_object(
-        const std::string_view& _name,
-        const size_t            _size,
-        OutputObjectType*       _parent
+      const std::string_view& _name,
+      const size_t            _size,
+      OutputObjectType*       _parent
     ) const noexcept {
       msgpack_pack_str(pk_, _name.size());
       msgpack_pack_str_body(pk_, _name.data(), _name.size());
       return new_array(_size);
     }
 
-    OutputObjectType add_object_to_array(
-        const size_t     _size,
-        OutputArrayType* _parent
-    ) const noexcept {
+    OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+      const noexcept {
       return new_object(_size);
     }
 
     OutputObjectType add_object_to_object(
-        const std::string_view& _name,
-        const size_t            _size,
-        OutputObjectType*       _parent
+      const std::string_view& _name,
+      const size_t            _size,
+      OutputObjectType*       _parent
     ) const noexcept {
       msgpack_pack_str(pk_, _name.size());
       msgpack_pack_str_body(pk_, _name.data(), _name.size());
@@ -88,16 +80,15 @@ namespace rfl::msgpack {
     }
 
     template <class T>
-    OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-        const noexcept {
+    OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
       return new_value(_var);
     }
 
     template <class T>
     OutputVarType add_value_to_object(
-        const std::string_view& _name,
-        const T&                _var,
-        OutputObjectType*       _parent
+      const std::string_view& _name,
+      const T&                _var,
+      OutputObjectType*       _parent
     ) const noexcept {
       msgpack_pack_str(pk_, _name.size());
       msgpack_pack_str_body(pk_, _name.data(), _name.size());
@@ -109,10 +100,8 @@ namespace rfl::msgpack {
       return OutputVarType {};
     }
 
-    OutputVarType add_null_to_object(
-        const std::string_view& _name,
-        OutputObjectType*       _parent
-    ) const noexcept {
+    OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+      const noexcept {
       msgpack_pack_str(pk_, _name.size());
       msgpack_pack_str_body(pk_, _name.data(), _name.size());
       msgpack_pack_nil(pk_);
diff --git a/include/rfl/msgpack/load.hpp b/include/rfl/msgpack/load.hpp
index d9c3121..4310ac0 100644
--- a/include/rfl/msgpack/load.hpp
+++ b/include/rfl/msgpack/load.hpp
@@ -10,9 +10,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_bytes = [](const auto& _bytes) {
-        return read<T, Ps...>(_bytes);
-      };
+      const auto read_bytes = [](const auto& _bytes) { return read<T, Ps...>(_bytes); };
       return rfl::io::load_bytes(_fname).and_then(read_bytes);
     }
 
diff --git a/include/rfl/msgpack/read.hpp b/include/rfl/msgpack/read.hpp
index 8862b4c..bd79ad1 100644
--- a/include/rfl/msgpack/read.hpp
+++ b/include/rfl/msgpack/read.hpp
@@ -25,8 +25,7 @@ namespace rfl {
 
     /// Parses an object from MSGPACK using reflection.
     template <class T, class... Ps>
-    Result<internal::wrap_in_rfl_array_t<T>>
-    read(const char* _bytes, const size_t _size) {
+    Result<internal::wrap_in_rfl_array_t<T>> read(const char* _bytes, const size_t _size) {
       msgpack_zone mempool;
       msgpack_zone_init(&mempool, 2048);
       msgpack_object deserialized;
diff --git a/include/rfl/named_tuple_t.hpp b/include/rfl/named_tuple_t.hpp
index 2fed352..50c4806 100644
--- a/include/rfl/named_tuple_t.hpp
+++ b/include/rfl/named_tuple_t.hpp
@@ -18,10 +18,8 @@ namespace rfl {
 
   template <internal::StringLiteral _name, class T>
   struct remove_ptr<Field<_name, T>> {
-    using FieldType = Field<
-        _name,
-        internal::wrap_in_rfl_array_t<
-            std::remove_cvref_t<std::remove_pointer_t<T>>>>;
+    using FieldType =
+      Field<_name, internal::wrap_in_rfl_array_t<std::remove_cvref_t<std::remove_pointer_t<T>>>>;
   };
 
   template <class T>
@@ -29,16 +27,14 @@ namespace rfl {
 
   template <class... FieldTypes>
   struct remove_ptrs_nt<NamedTuple<FieldTypes...>> {
-    using NamedTupleType =
-        NamedTuple<typename remove_ptr<FieldTypes>::FieldType...>;
+    using NamedTupleType = NamedTuple<typename remove_ptr<FieldTypes>::FieldType...>;
   };
 
   /// Generates the named tuple that is equivalent to the struct T.
   /// This is the result you would expect from calling
   /// to_named_tuple(my_struct). All fields of the struct must be an rfl::Field.
   template <class T>
-  using named_tuple_t =
-      typename remove_ptrs_nt<internal::ptr_named_tuple_t<T>>::NamedTupleType;
+  using named_tuple_t = typename remove_ptrs_nt<internal::ptr_named_tuple_t<T>>::NamedTupleType;
 
 } // namespace rfl
 
diff --git a/include/rfl/parsing/ArrayReader.hpp b/include/rfl/parsing/ArrayReader.hpp
index 517cfd3..f9efbe2 100644
--- a/include/rfl/parsing/ArrayReader.hpp
+++ b/include/rfl/parsing/ArrayReader.hpp
@@ -20,31 +20,25 @@ namespace rfl::parsing {
     static constexpr size_t size_ = _size;
 
    public:
-    ArrayReader(const R* _r, std::array<T, _size>* _array)
-        : array_(_array), i_(0), r_(_r) {}
+    ArrayReader(const R* _r, std::array<T, _size>* _array) : array_(_array), i_(0), r_(_r) {}
 
     ~ArrayReader() = default;
 
     std::optional<Error> check_size() const {
       if (i_ != size_) {
         return Error(
-            "Expected " + std::to_string(size_) + " elements, got " +
-            std::to_string(i_) + "."
+          "Expected " + std::to_string(size_) + " elements, got " + std::to_string(i_) + "."
         );
       }
       return std::nullopt;
     }
 
     std::optional<Error> read(const InputVarType& _var) const {
-      auto res =
-          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(*r_, _var);
+      auto res = Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(*r_, _var);
       if (res) {
         move_to(&((*array_)[i_]), &(*res));
       } else {
-        return Error(
-            "Failed to parse element " + std::to_string(i_) + ": " +
-            res.error()->what()
-        );
+        return Error("Failed to parse element " + std::to_string(i_) + ": " + res.error()->what());
       }
       ++i_;
       return std::nullopt;
@@ -54,8 +48,7 @@ namespace rfl::parsing {
     /// trigger the destructors.
     void call_destructors_where_necessary() const {
       for (size_t i = 0; i < std::min(i_, size_); ++i) {
-        if constexpr (!std::is_array_v<T> && std::is_pointer_v<T> &&
-                      std::is_destructible_v<T>) {
+        if constexpr (!std::is_array_v<T> && std::is_pointer_v<T> && std::is_destructible_v<T>) {
           (*array_)[i].~T();
         } else if constexpr (std::is_array_v<T>) {
           auto ptr = (*array_)[i];
@@ -80,17 +73,12 @@ namespace rfl::parsing {
     void move_to(Target* _t, Source* _s) const {
       if constexpr (std::is_const_v<Target>) {
         return move_to(const_cast<std::remove_const_t<Target>*>(_t), _s);
-      } else if constexpr (!internal::is_array_v<Source> &&
-                           !std::is_array_v<Target>) {
+      } else if constexpr (!internal::is_array_v<Source> && !std::is_array_v<Target>) {
         ::new (_t) Target(std::move(*_s));
       } else if constexpr (internal::is_array_v<Source>) {
-        for (size_t i = 0; i < _s->arr_.size(); ++i) {
-          move_to(&((*_t)[i]), &(_s->arr_[i]));
-        }
+        for (size_t i = 0; i < _s->arr_.size(); ++i) { move_to(&((*_t)[i]), &(_s->arr_[i])); }
       } else {
-        for (size_t i = 0; i < _s->size(); ++i) {
-          move_to(&((*_t)[i]), &((*_s)[i]));
-        }
+        for (size_t i = 0; i < _s->size(); ++i) { move_to(&((*_t)[i]), &((*_s)[i])); }
       }
     }
 
diff --git a/include/rfl/parsing/CustomParser.hpp b/include/rfl/parsing/CustomParser.hpp
index bb1be72..44588c8 100644
--- a/include/rfl/parsing/CustomParser.hpp
+++ b/include/rfl/parsing/CustomParser.hpp
@@ -12,15 +12,9 @@
 namespace rfl {
   namespace parsing {
 
-    template <
-        class R,
-        class W,
-        class ProcessorsType,
-        class OriginalClass,
-        class HelperStruct>
+    template <class R, class W, class ProcessorsType, class OriginalClass, class HelperStruct>
     struct CustomParser {
-      static Result<OriginalClass>
-      read(const R& _r, const auto& _var) noexcept {
+      static Result<OriginalClass> read(const R& _r, const auto& _var) noexcept {
         const auto to_class = [](auto&& _h) -> Result<OriginalClass> {
           try {
             if constexpr (internal::has_to_class_method_v<HelperStruct>) {
@@ -34,23 +28,20 @@ namespace rfl {
             }
           } catch (std::exception& e) { return Error(e.what()); }
         };
-        return Parser<R, W, HelperStruct, ProcessorsType>::read(_r, _var)
-            .and_then(to_class);
+        return Parser<R, W, HelperStruct, ProcessorsType>::read(_r, _var).and_then(to_class);
       }
 
       template <class P>
-      static auto
-      write(const W& _w, const OriginalClass& _p, const P& _parent) noexcept {
+      static auto write(const W& _w, const OriginalClass& _p, const P& _parent) noexcept {
         Parser<R, W, HelperStruct, ProcessorsType>::write(
-            _w, HelperStruct::from_class(_p), _parent
+          _w, HelperStruct::from_class(_p), _parent
         );
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<HelperStruct>, ProcessorsType>::
-            to_schema(_definitions);
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<HelperStruct>, ProcessorsType>::to_schema(
+          _definitions
+        );
       }
     };
 
diff --git a/include/rfl/parsing/FieldVariantParser.hpp b/include/rfl/parsing/FieldVariantParser.hpp
index bc91a2f..55e9ef9 100644
--- a/include/rfl/parsing/FieldVariantParser.hpp
+++ b/include/rfl/parsing/FieldVariantParser.hpp
@@ -33,25 +33,23 @@ namespace rfl {
 
       static ResultType read(const R& _r, const InputVarType& _var) noexcept {
         static_assert(
-            internal::no_duplicate_field_names<std::tuple<FieldTypes...>>(),
-            "Externally tagged variants cannot have duplicate field "
-            "names."
+          internal::no_duplicate_field_names<std::tuple<FieldTypes...>>(),
+          "Externally tagged variants cannot have duplicate field "
+          "names."
         );
 
         const auto to_result = [&](const auto _obj) -> ResultType {
           auto       field_variant = std::optional<Result<FieldVariantType>>();
           const auto reader =
-              FieldVariantReader<R, W, ProcessorsType, FieldTypes...>(
-                  &_r, &field_variant
-              );
+            FieldVariantReader<R, W, ProcessorsType, FieldTypes...>(&_r, &field_variant);
           auto err = _r.read_object(reader, _obj);
           if (err) {
             return *err;
           }
           if (!field_variant) {
             return Error(
-                "Could not parse: Expected the object to have "
-                "exactly one field, but found more than one."
+              "Could not parse: Expected the object to have "
+              "exactly one field, but found more than one."
             );
           }
           return std::move(*field_variant);
@@ -61,36 +59,29 @@ namespace rfl {
       }
 
       template <class P>
-      static void write(
-          const W&                           _w,
-          const std::variant<FieldTypes...>& _v,
-          const P&                           _parent
-      ) noexcept {
+      static void
+      write(const W& _w, const std::variant<FieldTypes...>& _v, const P& _parent) noexcept {
         static_assert(
-            internal::no_duplicate_field_names<std::tuple<FieldTypes...>>(),
-            "Externally tagged variants cannot have duplicate field "
-            "names."
+          internal::no_duplicate_field_names<std::tuple<FieldTypes...>>(),
+          "Externally tagged variants cannot have duplicate field "
+          "names."
         );
 
         const auto handle = [&](const auto& _field) {
-          const auto named_tuple =
-              make_named_tuple(internal::to_ptr_field(_field));
-          using NamedTupleType = std::remove_cvref_t<decltype(named_tuple)>;
-          Parser<R, W, NamedTupleType, ProcessorsType>::write(
-              _w, named_tuple, _parent
-          );
+          const auto named_tuple = make_named_tuple(internal::to_ptr_field(_field));
+          using NamedTupleType   = std::remove_cvref_t<decltype(named_tuple)>;
+          Parser<R, W, NamedTupleType, ProcessorsType>::write(_w, named_tuple, _parent);
         };
 
         std::visit(handle, _v);
       }
 
       static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions,
-          std::vector<schema::Type>            _types = {}
+        std::map<std::string, schema::Type>* _definitions,
+        std::vector<schema::Type>            _types = {}
       ) {
         using VariantType = std::variant<NamedTuple<FieldTypes>...>;
-        return Parser<R, W, VariantType, ProcessorsType>::to_schema(_definitions
-        );
+        return Parser<R, W, VariantType, ProcessorsType>::to_schema(_definitions);
       }
     };
   } // namespace parsing
diff --git a/include/rfl/parsing/FieldVariantReader.hpp b/include/rfl/parsing/FieldVariantReader.hpp
index 7acdcdc..e610fed 100644
--- a/include/rfl/parsing/FieldVariantReader.hpp
+++ b/include/rfl/parsing/FieldVariantReader.hpp
@@ -21,30 +21,26 @@ namespace rfl::parsing {
     using ResultType       = Result<FieldVariantType>;
 
    public:
-    FieldVariantReader(
-        const R*                                 _r,
-        std::optional<Result<FieldVariantType>>* _field_variant
-    )
-        : r_(_r), field_variant_(_field_variant) {}
+    FieldVariantReader(const R* _r, std::optional<Result<FieldVariantType>>* _field_variant)
+      : r_(_r), field_variant_(_field_variant) {}
 
     ~FieldVariantReader() = default;
 
     template <size_t _i = 0>
-    void read(const std::string_view& _disc_value, const InputVarType& _var)
-        const noexcept {
+    void read(const std::string_view& _disc_value, const InputVarType& _var) const noexcept {
       if constexpr (_i < sizeof...(FieldTypes)) {
         if constexpr (_i == 0) {
           if (*field_variant_) {
             *field_variant_ = Error(
-                "Could not parse: Expected the object to have "
-                "exactly one field, but found more than one."
+              "Could not parse: Expected the object to have "
+              "exactly one field, but found more than one."
             );
             return;
           }
         }
 
-        using FieldType = std::remove_cvref_t<
-            typename std::tuple_element<_i, std::tuple<FieldTypes...>>::type>;
+        using FieldType =
+          std::remove_cvref_t<typename std::tuple_element<_i, std::tuple<FieldTypes...>>::type>;
 
         using ValueType = std::remove_cvref_t<typename FieldType::Type>;
 
@@ -56,23 +52,22 @@ namespace rfl::parsing {
           };
           const auto embellish_error = [&](const Error& _e) {
             return Error(
-                "Could not parse std::variant with field '" +
-                std::string(_disc_value) + "': " + _e.what()
+              "Could not parse std::variant with field '" + std::string(_disc_value) +
+              "': " + _e.what()
             );
           };
-          *field_variant_ =
-              Parser<R, W, ValueType, ProcessorsType>::read(*r_, _var)
-                  .transform(to_variant)
-                  .or_else(embellish_error);
+          *field_variant_ = Parser<R, W, ValueType, ProcessorsType>::read(*r_, _var)
+                              .transform(to_variant)
+                              .or_else(embellish_error);
           return;
         } else {
           read<_i + 1>(_disc_value, _var);
         }
       } else {
         *field_variant_ = Error(
-            "Could not parse std::variant, could not match field named "
-            "'" +
-            std::string(_disc_value) + "'."
+          "Could not parse std::variant, could not match field named "
+          "'" +
+          std::string(_disc_value) + "'."
         );
       }
     }
diff --git a/include/rfl/parsing/IsReader.hpp b/include/rfl/parsing/IsReader.hpp
index e5e926f..a97e12a 100644
--- a/include/rfl/parsing/IsReader.hpp
+++ b/include/rfl/parsing/IsReader.hpp
@@ -18,27 +18,24 @@ namespace rfl {
 
     template <class R>
     struct MockArrayReader {
-      std::optional<Error> read(typename R::InputVarType& _var) const {
-        return std::nullopt;
-      }
+      std::optional<Error> read(typename R::InputVarType& _var) const { return std::nullopt; }
     };
 
     template <class R>
     struct MockObjectReader {
-      void read(const std::string_view& _name, typename R::InputVarType& _var)
-          const {}
+      void read(const std::string_view& _name, typename R::InputVarType& _var) const {}
     };
 
     template <class R, class T>
     concept IsReader = requires(
-        R                                             r,
-        std::string                                   name,
-        std::function<std::int16_t(std::string_view)> fct,
-        MockArrayReader<R>                            array_reader,
-        MockObjectReader<R>                           object_reader,
-        typename R::InputArrayType                    arr,
-        typename R::InputObjectType                   obj,
-        typename R::InputVarType                      var
+      R                                             r,
+      std::string                                   name,
+      std::function<std::int16_t(std::string_view)> fct,
+      MockArrayReader<R>                            array_reader,
+      MockObjectReader<R>                           object_reader,
+      typename R::InputArrayType                    arr,
+      typename R::InputObjectType                   obj,
+      typename R::InputVarType                      var
     ) {
       /// Any Reader needs to define the following:
       ///
@@ -52,9 +49,7 @@ namespace rfl {
       ///    be called something like from_json_obj(...).
 
       /// Retrieves a particular field from an object.
-      {
-        r.get_field(name, obj)
-      } -> std::same_as<rfl::Result<typename R::InputVarType>>;
+      { r.get_field(name, obj) } -> std::same_as<rfl::Result<typename R::InputVarType>>;
 
       /// Determines whether a variable is empty (the NULL type).
       { r.is_empty(var) } -> std::same_as<bool>;
@@ -66,9 +61,7 @@ namespace rfl {
       /// Iterates through an object and writes the key-value pairs into an
       /// object reader. This is what we use to handle structs and named tuples,
       /// making it a very important function.
-      {
-        r.read_object(object_reader, obj)
-      } -> std::same_as<std::optional<Error>>;
+      { r.read_object(object_reader, obj) } -> std::same_as<std::optional<Error>>;
 
       /// Transforms var to a basic type (bool, integral,
       /// floating point, std::string)
@@ -77,14 +70,10 @@ namespace rfl {
       } -> std::same_as<rfl::Result<internal::wrap_in_rfl_array_t<T>>>;
 
       /// Casts var as an InputArrayType.
-      {
-        r.to_array(var)
-      } -> std::same_as<rfl::Result<typename R::InputArrayType>>;
+      { r.to_array(var) } -> std::same_as<rfl::Result<typename R::InputArrayType>>;
 
       /// Casts var as an InputObjectType.
-      {
-        r.to_object(var)
-      } -> std::same_as<rfl::Result<typename R::InputObjectType>>;
+      { r.to_object(var) } -> std::same_as<rfl::Result<typename R::InputObjectType>>;
 
       /// Uses the custom constructor, if it has been determined that T has one
       /// (see above).
diff --git a/include/rfl/parsing/IsWriter.hpp b/include/rfl/parsing/IsWriter.hpp
index 853403c..50ba341 100644
--- a/include/rfl/parsing/IsWriter.hpp
+++ b/include/rfl/parsing/IsWriter.hpp
@@ -12,14 +12,14 @@ namespace rfl {
 
     template <class W, class T>
     concept IsWriter = requires(
-        W                            w,
-        T                            t,
-        std::string_view             name,
-        std::string                  basic_value,
-        typename W::OutputArrayType  arr,
-        typename W::OutputObjectType obj,
-        typename W::OutputVarType    var,
-        size_t                       size
+      W                            w,
+      T                            t,
+      std::string_view             name,
+      std::string                  basic_value,
+      typename W::OutputArrayType  arr,
+      typename W::OutputObjectType obj,
+      typename W::OutputVarType    var,
+      size_t                       size
     ) {
       /// Sets an empty array as the root element of the document.
       /// Some serialization formats require you to pass the expected size in
@@ -40,48 +40,34 @@ namespace rfl {
 
       /// Sets a basic value (bool, numeric, string) as the root element of the
       /// document. Returns an OutputVarType containing the new value.
-      {
-        w.value_as_root(basic_value)
-      } -> std::same_as<typename W::OutputVarType>;
+      { w.value_as_root(basic_value) } -> std::same_as<typename W::OutputVarType>;
 
       /// Adds an empty array to an existing array. Returns the new
       /// array for further modification.
-      {
-        w.add_array_to_array(size, &arr)
-      } -> std::same_as<typename W::OutputArrayType>;
+      { w.add_array_to_array(size, &arr) } -> std::same_as<typename W::OutputArrayType>;
 
       /// Adds an empty object to an existing array. Returns the new
       /// object for further modification.
-      {
-        w.add_object_to_array(size, &arr)
-      } -> std::same_as<typename W::OutputObjectType>;
+      { w.add_object_to_array(size, &arr) } -> std::same_as<typename W::OutputObjectType>;
 
       /// Adds an empty array to an existing object. The key or name of the
       /// field is signified by `name`. Returns the new array for further
       /// modification.
-      {
-        w.add_array_to_object(name, size, &obj)
-      } -> std::same_as<typename W::OutputArrayType>;
+      { w.add_array_to_object(name, size, &obj) } -> std::same_as<typename W::OutputArrayType>;
 
       /// Adds an empty object to an existing object. The key or name of the
       /// field is signified by `name`. Returns the new object for further
       /// modification.
-      {
-        w.add_object_to_object(name, size, &obj)
-      } -> std::same_as<typename W::OutputObjectType>;
+      { w.add_object_to_object(name, size, &obj) } -> std::same_as<typename W::OutputObjectType>;
 
       /// Adds a basic value (bool, numeric, string) to an array. Returns an
       /// OutputVarType containing the new value.
-      {
-        w.add_value_to_array(basic_value, &arr)
-      } -> std::same_as<typename W::OutputVarType>;
+      { w.add_value_to_array(basic_value, &arr) } -> std::same_as<typename W::OutputVarType>;
 
       /// Adds a basic value (bool, numeric, string) to an existing object. The
       /// key or name of the field is signified by `name`. Returns an
       /// OutputVarType containing the new value.
-      {
-        w.add_value_to_object(name, basic_value, &obj)
-      } -> std::same_as<typename W::OutputVarType>;
+      { w.add_value_to_object(name, basic_value, &obj) } -> std::same_as<typename W::OutputVarType>;
 
       /// Adds a null value to an array. Returns an
       /// OutputVarType containing the null value.
@@ -90,9 +76,7 @@ namespace rfl {
       /// Adds a null value to an existing object. The key
       /// or name of the field is signified by `name`. Returns an
       /// OutputVarType containing the null value.
-      {
-        w.add_null_to_object(name, &obj)
-      } -> std::same_as<typename W::OutputVarType>;
+      { w.add_null_to_object(name, &obj) } -> std::same_as<typename W::OutputVarType>;
 
       /// Signifies to the writer that we do not want to add any further
       /// elements to this array. Some serialization formats require this. If
diff --git a/include/rfl/parsing/MapParser.hpp b/include/rfl/parsing/MapParser.hpp
index 64cdf4f..4e35b04 100644
--- a/include/rfl/parsing/MapParser.hpp
+++ b/include/rfl/parsing/MapParser.hpp
@@ -28,75 +28,61 @@ namespace rfl {
       using OutputObjectType = typename W::OutputObjectType;
       using OutputVarType    = typename W::OutputVarType;
 
-      using KeyType =
-          std::remove_cvref_t<typename MapType::value_type::first_type>;
-      using ValueType =
-          std::remove_cvref_t<typename MapType::value_type::second_type>;
+      using KeyType   = std::remove_cvref_t<typename MapType::value_type::first_type>;
+      using ValueType = std::remove_cvref_t<typename MapType::value_type::second_type>;
 
       using ParentType = Parent<W>;
 
-      static Result<MapType>
-      read(const R& _r, const InputVarType& _var) noexcept {
-        const auto to_map = [&](auto obj) -> Result<MapType> {
-          return make_map(_r, obj);
-        };
+      static Result<MapType> read(const R& _r, const InputVarType& _var) noexcept {
+        const auto to_map = [&](auto obj) -> Result<MapType> { return make_map(_r, obj); };
         return _r.to_object(_var).and_then(to_map);
       }
 
       template <class P>
-      static void
-      write(const W& _w, const MapType& _m, const P& _parent) noexcept {
+      static void write(const W& _w, const MapType& _m, const P& _parent) noexcept {
         auto obj = ParentType::add_object(_w, _m.size(), _parent);
         for (const auto& [k, v] : _m) {
           if constexpr (internal::has_reflection_type_v<KeyType>) {
             using ReflT = typename KeyType::ReflectionType;
 
-            if constexpr (std::is_integral_v<ReflT> ||
-                          std::is_floating_point_v<ReflT>) {
+            if constexpr (std::is_integral_v<ReflT> || std::is_floating_point_v<ReflT>) {
               const auto name       = std::to_string(k.reflection());
-              const auto new_parent = typename ParentType::Object {name, &obj};
-              Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::
-                  write(_w, v, new_parent);
+              const auto new_parent = typename ParentType::Object { name, &obj };
+              Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::write(
+                _w, v, new_parent
+              );
             } else {
               const auto name       = k.reflection();
-              const auto new_parent = typename ParentType::Object {name, &obj};
-              Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::
-                  write(_w, v, new_parent);
+              const auto new_parent = typename ParentType::Object { name, &obj };
+              Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::write(
+                _w, v, new_parent
+              );
             }
 
-          } else if constexpr (std::is_integral_v<KeyType> ||
-                               std::is_floating_point_v<KeyType>) {
+          } else if constexpr (std::is_integral_v<KeyType> || std::is_floating_point_v<KeyType>) {
             const auto name       = std::to_string(k);
-            const auto new_parent = typename ParentType::Object {name, &obj};
-            Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::write(
-                _w, v, new_parent
-            );
+            const auto new_parent = typename ParentType::Object { name, &obj };
+            Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::write(_w, v, new_parent);
           } else {
-            const auto new_parent = typename ParentType::Object {k, &obj};
-            Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::write(
-                _w, v, new_parent
-            );
+            const auto new_parent = typename ParentType::Object { k, &obj };
+            Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::write(_w, v, new_parent);
           }
         }
         _w.end_object(&obj);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return schema::Type {schema::Type::StringMap {Ref<schema::Type>::make(
-            Parser<R, W, ValueType, ProcessorsType>::to_schema(_definitions)
-        )}};
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return schema::Type { schema::Type::StringMap {
+          Ref<schema::Type>::make(Parser<R, W, ValueType, ProcessorsType>::to_schema(_definitions)
+          ) } };
       }
 
      private:
-      static Result<MapType>
-      make_map(const R& _r, const InputObjectType& _obj) {
+      static Result<MapType> make_map(const R& _r, const InputObjectType& _obj) {
         MapType            map;
         std::vector<Error> errors;
-        const auto         map_reader =
-            MapReader<R, W, MapType, ProcessorsType>(&_r, &map, &errors);
-        const auto err = _r.read_object(map_reader, _obj);
+        const auto map_reader = MapReader<R, W, MapType, ProcessorsType>(&_r, &map, &errors);
+        const auto err        = _r.read_object(map_reader, _obj);
         if (err) {
           return *err;
         }
diff --git a/include/rfl/parsing/MapReader.hpp b/include/rfl/parsing/MapReader.hpp
index e6bcfe0..04d66cf 100644
--- a/include/rfl/parsing/MapReader.hpp
+++ b/include/rfl/parsing/MapReader.hpp
@@ -16,27 +16,23 @@ namespace rfl::parsing {
   class MapReader {
    private:
     using InputVarType = typename R::InputVarType;
-    using KeyType =
-        std::remove_cvref_t<typename MapType::value_type::first_type>;
-    using ValueType =
-        std::remove_cvref_t<typename MapType::value_type::second_type>;
+    using KeyType      = std::remove_cvref_t<typename MapType::value_type::first_type>;
+    using ValueType    = std::remove_cvref_t<typename MapType::value_type::second_type>;
 
    public:
     MapReader(const R* _r, MapType* _map, std::vector<Error>* _errors)
-        : r_(_r), map_(_map), errors_(_errors) {}
+      : r_(_r), map_(_map), errors_(_errors) {}
 
     ~MapReader() = default;
 
-    void read(const std::string_view& _name, const InputVarType& _var)
-        const noexcept {
+    void read(const std::string_view& _name, const InputVarType& _var) const noexcept {
       auto res = get_pair(_name, _var);
       if (res) {
         map_->emplace(std::move(*res));
       } else {
-        errors_->push_back(Error(
-            "Failed to parse field '" + std::string(_name) +
-            "': " + res.error()->what()
-        ));
+        errors_->push_back(
+          Error("Failed to parse field '" + std::string(_name) + "': " + res.error()->what())
+        );
       }
     }
 
@@ -57,24 +53,19 @@ namespace rfl::parsing {
     }
 
     Result<std::pair<KeyType, ValueType>> make_key(auto& _pair) const noexcept {
-      const auto to_pair = [&](auto _key
-                           ) -> Result<std::pair<KeyType, ValueType>> {
+      const auto to_pair = [&](auto _key) -> Result<std::pair<KeyType, ValueType>> {
         try {
-          return std::make_pair(
-              KeyType(std::move(_key)), std::move(_pair.second)
-          );
+          return std::make_pair(KeyType(std::move(_key)), std::move(_pair.second));
         } catch (std::exception& e) { return Error(e.what()); }
       };
 
-      if constexpr (std::is_integral_v<KeyType> ||
-                    std::is_floating_point_v<KeyType>) {
+      if constexpr (std::is_integral_v<KeyType> || std::is_floating_point_v<KeyType>) {
         return key_to_numeric<KeyType>(_pair).and_then(to_pair);
 
       } else if constexpr (internal::has_reflection_type_v<KeyType>) {
         using ReflT = typename KeyType::ReflectionType;
 
-        if constexpr (std::is_integral_v<ReflT> ||
-                      std::is_floating_point_v<ReflT>) {
+        if constexpr (std::is_integral_v<ReflT> || std::is_floating_point_v<ReflT>) {
           return key_to_numeric<ReflT>(_pair).and_then(to_pair);
         } else {
           return to_pair(_pair.first);
@@ -85,18 +76,15 @@ namespace rfl::parsing {
       }
     }
 
-    Result<std::pair<KeyType, ValueType>> get_pair(
-        const std::string_view& _name,
-        const InputVarType&     _var
-    ) const noexcept {
+    Result<std::pair<KeyType, ValueType>>
+    get_pair(const std::string_view& _name, const InputVarType& _var) const noexcept {
       const auto to_pair = [&](ValueType&& _val) {
         auto pair = std::make_pair(std::string(_name), std::move(_val));
         return make_key(pair);
       };
-      return Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::read(
-                 *r_, _var
-      )
-          .and_then(to_pair);
+      return Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::read(*r_, _var).and_then(
+        to_pair
+      );
     }
 
    private:
diff --git a/include/rfl/parsing/NamedTupleParser.hpp b/include/rfl/parsing/NamedTupleParser.hpp
index a1778ec..ad960d3 100644
--- a/include/rfl/parsing/NamedTupleParser.hpp
+++ b/include/rfl/parsing/NamedTupleParser.hpp
@@ -31,12 +31,12 @@ namespace rfl {
   namespace parsing {
 
     template <
-        class R,
-        class W,
-        bool _ignore_empty_containers,
-        bool _all_required,
-        class ProcessorsType,
-        class... FieldTypes>
+      class R,
+      class W,
+      bool _ignore_empty_containers,
+      bool _all_required,
+      class ProcessorsType,
+      class... FieldTypes>
       requires AreReaderAndWriter<R, W, NamedTuple<FieldTypes...>>
     struct NamedTupleParser {
       using InputObjectType = typename R::InputObjectType;
@@ -58,13 +58,11 @@ namespace rfl {
       /// fields might not be default-constructible.
       static Result<NamedTuple<FieldTypes...>>
       read(const R& _r, const InputVarType& _var) noexcept {
-        alignas(NamedTuple<FieldTypes...>) unsigned char
-             buf[sizeof(NamedTuple<FieldTypes...>)];
+        alignas(NamedTuple<FieldTypes...>) unsigned char buf[sizeof(NamedTuple<FieldTypes...>)];
         auto ptr       = reinterpret_cast<NamedTuple<FieldTypes...>*>(buf);
         auto view      = rfl::to_view(*ptr);
         using ViewType = std::remove_cvref_t<decltype(view)>;
-        const auto err =
-            Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
+        const auto err = Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
         if (err) [[unlikely]] {
           return *err;
         }
@@ -72,11 +70,8 @@ namespace rfl {
       }
 
       /// Reads the data into a view.
-      static std::optional<Error> read_view(
-          const R&                   _r,
-          const InputVarType&        _var,
-          NamedTuple<FieldTypes...>* _view
-      ) noexcept {
+      static std::optional<Error>
+      read_view(const R& _r, const InputVarType& _var, NamedTuple<FieldTypes...>* _view) noexcept {
         auto obj = _r.to_object(_var);
         if (!obj) [[unlikely]] {
           return obj.error();
@@ -87,11 +82,8 @@ namespace rfl {
       /// For writing, we do not need to make the distinction between
       /// default-constructible and non-default constructible fields.
       template <class P>
-      static void write(
-          const W&                         _w,
-          const NamedTuple<FieldTypes...>& _tup,
-          const P&                         _parent
-      ) noexcept {
+      static void
+      write(const W& _w, const NamedTuple<FieldTypes...>& _tup, const P& _parent) noexcept {
         auto obj = ParentType::add_object(_w, _tup.size(), _parent);
         build_object_recursively(_w, _tup, &obj);
         _w.end_object(&obj);
@@ -101,21 +93,20 @@ namespace rfl {
       /// between default-constructible and non-default constructible fields.
       template <size_t _i = 0>
       static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions,
-          std::map<std::string, schema::Type>  _values = {}
+        std::map<std::string, schema::Type>* _definitions,
+        std::map<std::string, schema::Type>  _values = {}
       ) {
         using Type            = schema::Type;
         using T               = NamedTuple<FieldTypes...>;
         constexpr size_t size = T::size();
         if constexpr (_i == size) {
-          return Type {Type::Object {_values}};
+          return Type { Type::Object { _values } };
         } else {
-          using F = std::
-              tuple_element_t<_i, typename NamedTuple<FieldTypes...>::Fields>;
+          using F = std::tuple_element_t<_i, typename NamedTuple<FieldTypes...>::Fields>;
           using U = typename F::Type;
           if constexpr (!internal::is_skip_v<U>) {
             _values[std::string(F::name())] =
-                Parser<R, W, U, ProcessorsType>::to_schema(_definitions);
+              Parser<R, W, U, ProcessorsType>::to_schema(_definitions);
           }
           return to_schema<_i + 1>(_definitions, _values);
         }
@@ -124,41 +115,33 @@ namespace rfl {
      private:
       template <int _i = 0>
       static void build_object_recursively(
-          const W&                         _w,
-          const NamedTuple<FieldTypes...>& _tup,
-          OutputObjectType*                _ptr
+        const W&                         _w,
+        const NamedTuple<FieldTypes...>& _tup,
+        OutputObjectType*                _ptr
       ) noexcept {
         if constexpr (_i >= sizeof...(FieldTypes)) {
           return;
         } else {
-          using FieldType =
-              typename std::tuple_element<_i, std::tuple<FieldTypes...>>::type;
+          using FieldType      = typename std::tuple_element<_i, std::tuple<FieldTypes...>>::type;
           using ValueType      = std::remove_cvref_t<typename FieldType::Type>;
           const auto&    value = rfl::get<_i>(_tup);
           constexpr auto name  = FieldType::name_.string_view();
-          const auto     new_parent = typename ParentType::Object {name, _ptr};
-          if constexpr (!_all_required &&
-                        !is_required<ValueType, _ignore_empty_containers>()) {
+          const auto     new_parent = typename ParentType::Object { name, _ptr };
+          if constexpr (!_all_required && !is_required<ValueType, _ignore_empty_containers>()) {
             if (!is_empty(value)) {
               if constexpr (internal::is_attribute_v<ValueType>) {
                 Parser<R, W, ValueType, ProcessorsType>::write(
-                    _w, value, new_parent.as_attribute()
+                  _w, value, new_parent.as_attribute()
                 );
               } else {
-                Parser<R, W, ValueType, ProcessorsType>::write(
-                    _w, value, new_parent
-                );
+                Parser<R, W, ValueType, ProcessorsType>::write(_w, value, new_parent);
               }
             }
           } else {
             if constexpr (internal::is_attribute_v<ValueType>) {
-              Parser<R, W, ValueType, ProcessorsType>::write(
-                  _w, value, new_parent.as_attribute()
-              );
+              Parser<R, W, ValueType, ProcessorsType>::write(_w, value, new_parent.as_attribute());
             } else {
-              Parser<R, W, ValueType, ProcessorsType>::write(
-                  _w, value, new_parent
-              );
+              Parser<R, W, ValueType, ProcessorsType>::write(_w, value, new_parent);
             }
           }
           return build_object_recursively<_i + 1>(_w, _tup, _ptr);
@@ -168,25 +151,21 @@ namespace rfl {
       /// Generates error messages for when fields are missing.
       template <int _i>
       static void handle_one_missing_field(
-          const std::array<bool, size_>& _found,
-          const NamedTupleType&          _view,
-          std::array<bool, size_>*       _set,
-          std::vector<Error>*            _errors
+        const std::array<bool, size_>& _found,
+        const NamedTupleType&          _view,
+        std::array<bool, size_>*       _set,
+        std::vector<Error>*            _errors
       ) noexcept {
-        using FieldType =
-            std::tuple_element_t<_i, typename NamedTupleType::Fields>;
-        using ValueType = std::remove_reference_t<
-            std::remove_pointer_t<typename FieldType::Type>>;
+        using FieldType = std::tuple_element_t<_i, typename NamedTupleType::Fields>;
+        using ValueType = std::remove_reference_t<std::remove_pointer_t<typename FieldType::Type>>;
 
         if (!std::get<_i>(_found)) {
-          if constexpr (_all_required ||
-                        is_required<ValueType, _ignore_empty_containers>()) {
+          if constexpr (_all_required || is_required<ValueType, _ignore_empty_containers>()) {
             constexpr auto current_name =
-                std::tuple_element_t<_i, typename NamedTupleType::Fields>::name(
-                );
-            _errors->emplace_back(Error(
-                "Field named '" + std::string(current_name) + "' not found."
-            ));
+              std::tuple_element_t<_i, typename NamedTupleType::Fields>::name();
+            _errors->emplace_back(
+              Error("Field named '" + std::string(current_name) + "' not found.")
+            );
           } else {
             if constexpr (!std::is_const_v<ValueType>) {
               ::new (rfl::get<_i>(_view)) ValueType();
@@ -206,30 +185,21 @@ namespace rfl {
         (handle_one_missing_field<_is>(_found, _view, _set, _errors), ...);
       }
 
-      static std::optional<Error> read_object(
-          const R&               _r,
-          const InputObjectType& _obj,
-          NamedTupleType*        _view
-      ) noexcept {
+      static std::optional<Error>
+      read_object(const R& _r, const InputObjectType& _obj, NamedTupleType* _view) noexcept {
         auto found = std::array<bool, NamedTupleType::size()>();
         found.fill(false);
         auto set = std::array<bool, NamedTupleType::size()>();
         set.fill(false);
         std::vector<Error> errors;
         const auto         object_reader =
-            ViewReader<R, W, NamedTupleType, ProcessorsType>(
-                &_r, _view, &found, &set, &errors
-            );
+          ViewReader<R, W, NamedTupleType, ProcessorsType>(&_r, _view, &found, &set, &errors);
         const auto err = _r.read_object(object_reader, _obj);
         if (err) {
           return *err;
         }
         handle_missing_fields(
-            found,
-            *_view,
-            &set,
-            &errors,
-            std::make_integer_sequence<int, size_>()
+          found, *_view, &set, &errors, std::make_integer_sequence<int, size_>()
         );
         if (errors.size() != 0) {
           object_reader.call_destructors_where_necessary();
diff --git a/include/rfl/parsing/Parent.hpp b/include/rfl/parsing/Parent.hpp
index 5a742f0..aabbf47 100644
--- a/include/rfl/parsing/Parent.hpp
+++ b/include/rfl/parsing/Parent.hpp
@@ -25,14 +25,13 @@ namespace rfl {
         std::string_view  name_;
         OutputObjectType* obj_;
         bool              is_attribute_ = false;
-        Object as_attribute() const { return Object {name_, obj_, true}; }
+        Object            as_attribute() const { return Object { name_, obj_, true }; }
       };
 
       struct Root {};
 
       template <class ParentType>
-      static OutputArrayType
-      add_array(const W& _w, const size_t _size, const ParentType& _parent) {
+      static OutputArrayType add_array(const W& _w, const size_t _size, const ParentType& _parent) {
         using Type = std::remove_cvref_t<ParentType>;
         if constexpr (std::is_same<Type, Array>()) {
           return _w.add_array_to_array(_size, _parent.arr_);
@@ -67,9 +66,7 @@ namespace rfl {
           return _w.add_null_to_array(_parent.arr_);
         } else if constexpr (std::is_same<Type, Object>()) {
           if constexpr (supports_attributes<std::remove_cvref_t<W>>) {
-            return _w.add_null_to_object(
-                _parent.name_, _parent.obj_, _parent.is_attribute_
-            );
+            return _w.add_null_to_object(_parent.name_, _parent.obj_, _parent.is_attribute_);
           } else {
             return _w.add_null_to_object(_parent.name_, _parent.obj_);
           }
@@ -81,16 +78,13 @@ namespace rfl {
       }
 
       template <class ParentType, class T>
-      static OutputVarType
-      add_value(const W& _w, const T& _var, const ParentType& _parent) {
+      static OutputVarType add_value(const W& _w, const T& _var, const ParentType& _parent) {
         using Type = std::remove_cvref_t<ParentType>;
         if constexpr (std::is_same<Type, Array>()) {
           return _w.add_value_to_array(_var, _parent.arr_);
         } else if constexpr (std::is_same<Type, Object>()) {
           if constexpr (supports_attributes<std::remove_cvref_t<W>>) {
-            return _w.add_value_to_object(
-                _parent.name_, _var, _parent.obj_, _parent.is_attribute_
-            );
+            return _w.add_value_to_object(_parent.name_, _var, _parent.obj_, _parent.is_attribute_);
           } else {
             return _w.add_value_to_object(_parent.name_, _var, _parent.obj_);
           }
diff --git a/include/rfl/parsing/Parser_array.hpp b/include/rfl/parsing/Parser_array.hpp
index 7217cd4..859382a 100644
--- a/include/rfl/parsing/Parser_array.hpp
+++ b/include/rfl/parsing/Parser_array.hpp
@@ -28,16 +28,12 @@ namespace rfl {
 
       using ParentType = Parent<W>;
 
-      static Result<std::array<T, _size>>
-      read(const R& _r, const InputVarType& _var) noexcept {
-        const auto parse = [&](const InputArrayType& _arr
-                           ) -> Result<std::array<T, _size>> {
-          alignas(std::array<T, _size>) unsigned char
-                     buf[sizeof(std::array<T, _size>)];
-          auto       ptr = reinterpret_cast<std::array<T, _size>*>(buf);
-          const auto array_reader =
-              ArrayReader<R, W, ProcessorsType, T, _size>(&_r, ptr);
-          auto err = _r.read_array(array_reader, _arr);
+      static Result<std::array<T, _size>> read(const R& _r, const InputVarType& _var) noexcept {
+        const auto parse = [&](const InputArrayType& _arr) -> Result<std::array<T, _size>> {
+          alignas(std::array<T, _size>) unsigned char buf[sizeof(std::array<T, _size>)];
+          auto       ptr          = reinterpret_cast<std::array<T, _size>*>(buf);
+          const auto array_reader = ArrayReader<R, W, ProcessorsType, T, _size>(&_r, ptr);
+          auto       err          = _r.read_array(array_reader, _arr);
           if (err) {
             array_reader.call_destructors_where_necessary();
             return *err;
@@ -54,32 +50,22 @@ namespace rfl {
       }
 
       template <class P>
-      static void write(
-          const W&                    _w,
-          const std::array<T, _size>& _arr,
-          const P&                    _parent
-      ) noexcept {
+      static void write(const W& _w, const std::array<T, _size>& _arr, const P& _parent) noexcept {
         auto       arr        = ParentType::add_array(_w, _size, _parent);
-        const auto new_parent = typename ParentType::Array {&arr};
+        const auto new_parent = typename ParentType::Array { &arr };
         for (const auto& e : _arr) {
-          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-              _w, e, new_parent
-          );
+          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, e, new_parent);
         }
         _w.end_array(&arr);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         using U = std::remove_cvref_t<T>;
         return schema::Type {
-            schema::Type::FixedSizeTypedArray {
-                                               .size_ = _size,
-                                               .type_ = Ref<schema::Type>::make(
-                    Parser<R, W, U, ProcessorsType>::to_schema(_definitions)
-                )
-            }
+          schema::Type::FixedSizeTypedArray {
+                                             .size_ = _size,
+                                             .type_ =
+              Ref<schema::Type>::make(Parser<R, W, U, ProcessorsType>::to_schema(_definitions)) }
         };
       }
     };
diff --git a/include/rfl/parsing/Parser_box.hpp b/include/rfl/parsing/Parser_box.hpp
index 6bed7ab..a5b776b 100644
--- a/include/rfl/parsing/Parser_box.hpp
+++ b/include/rfl/parsing/Parser_box.hpp
@@ -18,31 +18,19 @@ namespace rfl {
       using InputVarType  = typename R::InputVarType;
       using OutputVarType = typename W::OutputVarType;
 
-      static Result<Box<T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
-        const auto to_box = [](auto&& _t) {
-          return Box<T>::make(std::move(_t));
-        };
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                   _r, _var
-        )
-            .transform(to_box);
+      static Result<Box<T>> read(const R& _r, const InputVarType& _var) noexcept {
+        const auto to_box = [](auto&& _t) { return Box<T>::make(std::move(_t)); };
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(to_box
+        );
       }
 
       template <class P>
-      static void
-      write(const W& _w, const Box<T>& _box, const P& _parent) noexcept {
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, *_box, _parent
-        );
+      static void write(const W& _w, const Box<T>& _box, const P& _parent) noexcept {
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, *_box, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_c_array.hpp b/include/rfl/parsing/Parser_c_array.hpp
index 7c1a3b9..38ac3c0 100644
--- a/include/rfl/parsing/Parser_c_array.hpp
+++ b/include/rfl/parsing/Parser_c_array.hpp
@@ -29,31 +29,24 @@ namespace rfl {
       using ParentType = Parent<W>;
       using CArray     = T[_size];
 
-      static Result<internal::Array<CArray>>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<internal::Array<CArray>> read(const R& _r, const InputVarType& _var) noexcept {
         using StdArray = internal::to_std_array_t<CArray>;
         return Parser<R, W, StdArray, ProcessorsType>::read(_r, _var);
       }
 
       template <class P>
-      static void
-      write(const W& _w, const CArray& _arr, const P& _parent) noexcept {
+      static void write(const W& _w, const CArray& _arr, const P& _parent) noexcept {
         auto       arr        = ParentType::add_array(_w, _size, _parent);
-        const auto new_parent = typename ParentType::Array {&arr};
+        const auto new_parent = typename ParentType::Array { &arr };
         for (const auto& e : _arr) {
-          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-              _w, e, new_parent
-          );
+          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, e, new_parent);
         }
         _w.end_array(&arr);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         using StdArray = internal::to_std_array_t<CArray>;
-        return Parser<R, W, std::remove_cvref_t<StdArray>, ProcessorsType>::
-            to_schema(_definitions);
+        return Parser<R, W, std::remove_cvref_t<StdArray>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_default.hpp b/include/rfl/parsing/Parser_default.hpp
index cac139d..a5ffac2 100644
--- a/include/rfl/parsing/Parser_default.hpp
+++ b/include/rfl/parsing/Parser_default.hpp
@@ -44,21 +44,19 @@ namespace rfl {
           return _r.template use_custom_constructor<T>(_var);
         } else {
           if constexpr (internal::has_reflection_type_v<T>) {
-            using ReflectionType =
-                std::remove_cvref_t<typename T::ReflectionType>;
+            using ReflectionType = std::remove_cvref_t<typename T::ReflectionType>;
             const auto wrap_in_t = [](auto _named_tuple) -> Result<T> {
               try {
                 return T(_named_tuple);
               } catch (std::exception& e) { return Error(e.what()); }
             };
-            return Parser<R, W, ReflectionType, ProcessorsType>::read(_r, _var)
-                .and_then(wrap_in_t);
+            return Parser<R, W, ReflectionType, ProcessorsType>::read(_r, _var).and_then(wrap_in_t);
           } else if constexpr (std::is_class_v<T> && std::is_aggregate_v<T>) {
             return read_struct(_r, _var);
           } else if constexpr (std::is_enum_v<T>) {
             using StringConverter = internal::enums::StringConverter<T>;
             return _r.template to_basic_type<std::string>(_var).and_then(
-                StringConverter::string_to_enum
+              StringConverter::string_to_enum
             );
           } else {
             return _r.template to_basic_type<std::remove_cvref_t<T>>(_var);
@@ -69,25 +67,18 @@ namespace rfl {
       template <class P>
       static void write(const W& _w, const T& _var, const P& _parent) noexcept {
         if constexpr (internal::has_reflection_type_v<T>) {
-          using ReflectionType =
-              std::remove_cvref_t<typename T::ReflectionType>;
+          using ReflectionType = std::remove_cvref_t<typename T::ReflectionType>;
           if constexpr (internal::has_reflection_method_v<T>) {
-            Parser<R, W, ReflectionType, ProcessorsType>::write(
-                _w, _var.reflection(), _parent
-            );
+            Parser<R, W, ReflectionType, ProcessorsType>::write(_w, _var.reflection(), _parent);
           } else {
             const auto& [r] = _var;
             Parser<R, W, ReflectionType, ProcessorsType>::write(_w, r, _parent);
           }
         } else if constexpr (std::is_class_v<T> && std::is_aggregate_v<T>) {
-          const auto ptr_named_tuple = ProcessorsType::template process<T>(
-              internal::to_ptr_named_tuple(_var)
-          );
-          using PtrNamedTupleType =
-              std::remove_cvref_t<decltype(ptr_named_tuple)>;
-          Parser<R, W, PtrNamedTupleType, ProcessorsType>::write(
-              _w, ptr_named_tuple, _parent
-          );
+          const auto ptr_named_tuple =
+            ProcessorsType::template process<T>(internal::to_ptr_named_tuple(_var));
+          using PtrNamedTupleType = std::remove_cvref_t<decltype(ptr_named_tuple)>;
+          Parser<R, W, PtrNamedTupleType, ProcessorsType>::write(_w, ptr_named_tuple, _parent);
         } else if constexpr (std::is_enum_v<T>) {
           using StringConverter = internal::enums::StringConverter<T>;
           const auto str        = StringConverter::enum_to_string(_var);
@@ -98,37 +89,35 @@ namespace rfl {
       }
 
       /// Generates a schema for the underlying type.
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         using U    = std::remove_cvref_t<T>;
         using Type = schema::Type;
         if constexpr (std::is_same<U, bool>()) {
-          return Type {Type::Boolean {}};
+          return Type { Type::Boolean {} };
 
         } else if constexpr (std::is_same<U, std::int32_t>()) {
-          return Type {Type::Int32 {}};
+          return Type { Type::Int32 {} };
 
         } else if constexpr (std::is_same<U, std::int64_t>()) {
-          return Type {Type::Int64 {}};
+          return Type { Type::Int64 {} };
 
         } else if constexpr (std::is_same<U, std::uint32_t>()) {
-          return Type {Type::UInt32 {}};
+          return Type { Type::UInt32 {} };
 
         } else if constexpr (std::is_same<U, std::uint64_t>()) {
-          return Type {Type::UInt64 {}};
+          return Type { Type::UInt64 {} };
 
         } else if constexpr (std::is_integral<U>()) {
-          return Type {Type::Integer {}};
+          return Type { Type::Integer {} };
 
         } else if constexpr (std::is_same<U, float>()) {
-          return Type {Type::Float {}};
+          return Type { Type::Float {} };
 
         } else if constexpr (std::is_floating_point_v<U>) {
-          return Type {Type::Double {}};
+          return Type { Type::Double {} };
 
         } else if constexpr (std::is_same<U, std::string>()) {
-          return Type {Type::String {}};
+          return Type { Type::String {} };
 
         } else if constexpr (rfl::internal::is_description_v<U>) {
           return make_description<U>(_definitions);
@@ -140,14 +129,13 @@ namespace rfl {
           return make_reference<U>(_definitions);
 
         } else if constexpr (internal::is_literal_v<U>) {
-          return Type {Type::Literal {.values_ = U::strings()}};
+          return Type { Type::Literal { .values_ = U::strings() } };
 
         } else if constexpr (internal::is_validator_v<U>) {
           return make_validated<U>(_definitions);
 
         } else if constexpr (internal::has_reflection_type_v<U>) {
-          return Parser<R, W, typename U::ReflectionType, ProcessorsType>::
-              to_schema(_definitions);
+          return Parser<R, W, typename U::ReflectionType, ProcessorsType>::to_schema(_definitions);
 
         } else {
           static_assert(rfl::always_false_v<U>, "Unsupported type.");
@@ -156,79 +144,59 @@ namespace rfl {
 
      private:
       template <class U>
-      static schema::Type make_description(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type make_description(std::map<std::string, schema::Type>* _definitions) {
         using Type = schema::Type;
         return Type {
-            Type::Description {
-                               .description_ = typename U::Content().str(),
-                               .type_ =
-                    Ref<Type>::make(Parser<
-                                    R, W,
-                               std::remove_cvref_t<typename U::Type>,
-                               ProcessorsType>::to_schema(_definitions))
-            }
+          Type::Description {
+                             .description_ = typename U::Content().str(),
+                             .type_        = Ref<Type>::make(
+              Parser<R, W, std::remove_cvref_t<typename U::Type>, ProcessorsType>::to_schema(
+                _definitions
+              )
+            ) }
         };
       }
 
       template <class U>
-      static schema::Type make_enum(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type make_enum(std::map<std::string, schema::Type>* _definitions) {
         using Type = schema::Type;
         using S    = internal::enums::StringConverter<U>;
         if constexpr (S::is_flag_enum_) {
-          return Type {Type::String {}};
+          return Type { Type::String {} };
         } else {
-          return Parser<R, W, typename S::NamesLiteral, ProcessorsType>::
-              to_schema(_definitions);
+          return Parser<R, W, typename S::NamesLiteral, ProcessorsType>::to_schema(_definitions);
         }
       }
 
       template <class U>
-      static schema::Type make_reference(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type make_reference(std::map<std::string, schema::Type>* _definitions) {
         using Type      = schema::Type;
         const auto name = make_type_name<U>();
         if (_definitions->find(name) == _definitions->end()) {
+          (*_definitions)[name] = Type { Type::Integer {} }; // Placeholder to avoid infinite loop.
+          using NamedTupleType  = internal::processed_t<U, ProcessorsType>;
           (*_definitions)[name] =
-              Type {Type::Integer {}}; // Placeholder to avoid infinite loop.
-          using NamedTupleType = internal::processed_t<U, ProcessorsType>;
-          (*_definitions)[name] =
-              Parser<R, W, NamedTupleType, ProcessorsType>::to_schema(
-                  _definitions
-              );
+            Parser<R, W, NamedTupleType, ProcessorsType>::to_schema(_definitions);
         }
-        return Type {Type::Reference {name}};
+        return Type { Type::Reference { name } };
       }
 
       template <class U>
-      static schema::Type make_validated(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type make_validated(std::map<std::string, schema::Type>* _definitions) {
         using Type           = schema::Type;
         using ReflectionType = std::remove_cvref_t<typename U::ReflectionType>;
         using ValidationType = std::remove_cvref_t<typename U::ValidationType>;
         return Type {
-            Type::Validated {
-                             .type_ = Ref<Type>::make(
-                    Parser<R, W, ReflectionType, ProcessorsType>::to_schema(
-                        _definitions
-                    )
-                ), .validation_ =
-                    ValidationType::template to_schema<ReflectionType>()
-            }
+          Type::Validated { .type_ = Ref<Type>::make(
+                              Parser<R, W, ReflectionType, ProcessorsType>::to_schema(_definitions)
+                            ), .validation_ = ValidationType::template to_schema<ReflectionType>() }
         };
       }
 
       template <class U>
       static std::string make_type_name() {
         if constexpr (is_tagged_union_wrapper_v<U>) {
-          return replace_non_alphanumeric(
-              type_name_t<typename U::Type>().str() + "__tagged"
-          );
+          return replace_non_alphanumeric(type_name_t<typename U::Type>().str() + "__tagged");
         } else {
           return replace_non_alphanumeric(type_name_t<U>().str());
         }
@@ -240,11 +208,10 @@ namespace rfl {
       /// might not be default-constructible.
       static Result<T> read_struct(const R& _r, const InputVarType& _var) {
         alignas(T) unsigned char buf[sizeof(T)];
-        auto                     ptr = reinterpret_cast<T*>(buf);
-        auto view      = ProcessorsType::template process<T>(to_view(*ptr));
-        using ViewType = std::remove_cvref_t<decltype(view)>;
-        const auto err =
-            Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
+        auto                     ptr  = reinterpret_cast<T*>(buf);
+        auto                     view = ProcessorsType::template process<T>(to_view(*ptr));
+        using ViewType                = std::remove_cvref_t<decltype(view)>;
+        const auto err = Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
         if (err) [[unlikely]] {
           return *err;
         }
diff --git a/include/rfl/parsing/Parser_map_like.hpp b/include/rfl/parsing/Parser_map_like.hpp
index eb2bed1..ae78210 100644
--- a/include/rfl/parsing/Parser_map_like.hpp
+++ b/include/rfl/parsing/Parser_map_like.hpp
@@ -18,16 +18,12 @@ namespace rfl {
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::map<std::string, T>>
     struct Parser<R, W, std::map<std::string, T>, ProcessorsType>
-        : public MapParser<R, W, std::map<std::string, T>, ProcessorsType> {};
+      : public MapParser<R, W, std::map<std::string, T>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::unordered_map<std::string, T>>
     struct Parser<R, W, std::unordered_map<std::string, T>, ProcessorsType>
-        : public MapParser<
-              R,
-              W,
-              std::unordered_map<std::string, T>,
-              ProcessorsType> {};
+      : public MapParser<R, W, std::unordered_map<std::string, T>, ProcessorsType> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/Parser_named_tuple.hpp b/include/rfl/parsing/Parser_named_tuple.hpp
index f6ad9fa..501d960 100644
--- a/include/rfl/parsing/Parser_named_tuple.hpp
+++ b/include/rfl/parsing/Parser_named_tuple.hpp
@@ -10,13 +10,13 @@ namespace rfl {
     template <class R, class W, class... FieldTypes, class ProcessorsType>
       requires AreReaderAndWriter<R, W, NamedTuple<FieldTypes...>>
     struct Parser<R, W, NamedTuple<FieldTypes...>, ProcessorsType>
-        : public NamedTupleParser<
-              R,
-              W,
-              /*_ignore_empty_containers=*/false,
-              /*_all_required=*/ProcessorsType::all_required_,
-              ProcessorsType,
-              FieldTypes...> {};
+      : public NamedTupleParser<
+          R,
+          W,
+          /*_ignore_empty_containers=*/false,
+          /*_all_required=*/ProcessorsType::all_required_,
+          ProcessorsType,
+          FieldTypes...> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/Parser_optional.hpp b/include/rfl/parsing/Parser_optional.hpp
index be627e3..a36d2ee 100644
--- a/include/rfl/parsing/Parser_optional.hpp
+++ b/include/rfl/parsing/Parser_optional.hpp
@@ -23,40 +23,28 @@ namespace rfl {
 
       using ParentType = Parent<W>;
 
-      static Result<std::optional<T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<std::optional<T>> read(const R& _r, const InputVarType& _var) noexcept {
         if (_r.is_empty(_var)) {
           return std::optional<T>();
         }
         const auto to_opt = [](auto&& _t) { return std::make_optional<T>(_t); };
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                   _r, _var
-        )
-            .transform(to_opt);
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(to_opt
+        );
       }
 
       template <class P>
-      static void write(
-          const W&                _w,
-          const std::optional<T>& _o,
-          const P&                _parent
-      ) noexcept {
+      static void write(const W& _w, const std::optional<T>& _o, const P& _parent) noexcept {
         if (!_o) {
           ParentType::add_null(_w, _parent);
           return;
         }
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, *_o, _parent
-        );
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, *_o, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         using U = std::remove_cvref_t<T>;
-        return schema::Type {schema::Type::Optional {Ref<schema::Type>::make(
-            Parser<R, W, U, ProcessorsType>::to_schema(_definitions)
-        )}};
+        return schema::Type { schema::Type::Optional {
+          Ref<schema::Type>::make(Parser<R, W, U, ProcessorsType>::to_schema(_definitions)) } };
       }
     };
 
diff --git a/include/rfl/parsing/Parser_pair.hpp b/include/rfl/parsing/Parser_pair.hpp
index 99039de..50f57c5 100644
--- a/include/rfl/parsing/Parser_pair.hpp
+++ b/include/rfl/parsing/Parser_pair.hpp
@@ -14,12 +14,7 @@
 namespace rfl {
   namespace parsing {
 
-    template <
-        class R,
-        class W,
-        class FirstType,
-        class SecondType,
-        class ProcessorsType>
+    template <class R, class W, class FirstType, class SecondType, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::pair<FirstType, SecondType>>
     struct Parser<R, W, std::pair<FirstType, SecondType>, ProcessorsType> {
       using InputVarType  = typename R::InputVarType;
@@ -29,34 +24,25 @@ namespace rfl {
       static Result<std::pair<FirstType, SecondType>>
       read(const R& _r, const InputVarType& _var) noexcept {
         const auto to_pair = [&](auto&& _t) {
-          return std::make_pair(
-              std::move(std::get<0>(_t)), std::move(std::get<1>(_t))
-          );
+          return std::make_pair(std::move(std::get<0>(_t)), std::move(std::get<1>(_t)));
         };
-        return Parser<R, W, std::tuple<FirstType, SecondType>, ProcessorsType>::
-            read(_r, _var)
-                .transform(to_pair);
+        return Parser<R, W, std::tuple<FirstType, SecondType>, ProcessorsType>::read(_r, _var)
+          .transform(to_pair);
       }
 
       template <class P>
-      static void write(
-          const W&                                _w,
-          const std::pair<FirstType, SecondType>& _p,
-          const P&                                _parent
-      ) noexcept {
+      static void
+      write(const W& _w, const std::pair<FirstType, SecondType>& _p, const P& _parent) noexcept {
         const auto tup = std::make_tuple(&_p.first, &_p.second);
-        Parser<
-            R,
-            W,
-            std::tuple<const FirstType*, const SecondType*>,
-            ProcessorsType>::write(_w, tup, _parent);
+        Parser<R, W, std::tuple<const FirstType*, const SecondType*>, ProcessorsType>::write(
+          _w, tup, _parent
+        );
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::tuple<FirstType, SecondType>, ProcessorsType>::
-            to_schema(_definitions);
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::tuple<FirstType, SecondType>, ProcessorsType>::to_schema(
+          _definitions
+        );
       }
     };
 
diff --git a/include/rfl/parsing/Parser_ptr.hpp b/include/rfl/parsing/Parser_ptr.hpp
index 26e5628..551935b 100644
--- a/include/rfl/parsing/Parser_ptr.hpp
+++ b/include/rfl/parsing/Parser_ptr.hpp
@@ -25,12 +25,12 @@ namespace rfl {
       /// Expresses the variables as type T.
       static Result<T*> read(const R& _r, const InputVarType& _var) noexcept {
         static_assert(
-            always_false_v<T>,
-            "Reading into raw pointers is dangerous and "
-            "therefore unsupported. "
-            "Please consider using std::unique_ptr, rfl::Box, "
-            "std::shared_ptr, "
-            "rfl::Ref or std::optional instead."
+          always_false_v<T>,
+          "Reading into raw pointers is dangerous and "
+          "therefore unsupported. "
+          "Please consider using std::unique_ptr, rfl::Box, "
+          "std::shared_ptr, "
+          "rfl::Ref or std::optional instead."
         );
         return Error("Unsupported.");
       }
@@ -41,17 +41,11 @@ namespace rfl {
           ParentType::add_null(_w, _parent);
           return;
         }
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, *_ptr, _parent
-        );
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, *_ptr, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_ref.hpp b/include/rfl/parsing/Parser_ref.hpp
index 906e5bf..73c3432 100644
--- a/include/rfl/parsing/Parser_ref.hpp
+++ b/include/rfl/parsing/Parser_ref.hpp
@@ -19,31 +19,19 @@ namespace rfl {
       using InputVarType  = typename R::InputVarType;
       using OutputVarType = typename W::OutputVarType;
 
-      static Result<Ref<T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
-        const auto to_ref = [&](auto&& _t) {
-          return Ref<T>::make(std::move(_t));
-        };
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                   _r, _var
-        )
-            .transform(to_ref);
+      static Result<Ref<T>> read(const R& _r, const InputVarType& _var) noexcept {
+        const auto to_ref = [&](auto&& _t) { return Ref<T>::make(std::move(_t)); };
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(to_ref
+        );
       }
 
       template <class P>
-      static void
-      write(const W& _w, const Ref<T>& _ref, const P& _parent) noexcept {
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, *_ref, _parent
-        );
+      static void write(const W& _w, const Ref<T>& _ref, const P& _parent) noexcept {
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, *_ref, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_reference_wrapper.hpp b/include/rfl/parsing/Parser_reference_wrapper.hpp
index fa4af42..e7b71b2 100644
--- a/include/rfl/parsing/Parser_reference_wrapper.hpp
+++ b/include/rfl/parsing/Parser_reference_wrapper.hpp
@@ -22,33 +22,23 @@ namespace rfl {
       static Result<std::reference_wrapper<T>>
       read(const R& _r, const InputVarType& _var) noexcept {
         static_assert(
-            always_false_v<T>,
-            "Reading into std::reference_wrapper is dangerous and "
-            "therefore unsupported. "
-            "Please consider using std::unique_ptr, rfl::Box, "
-            "std::shared_ptr, or"
-            "rfl::Ref instead."
+          always_false_v<T>,
+          "Reading into std::reference_wrapper is dangerous and "
+          "therefore unsupported. "
+          "Please consider using std::unique_ptr, rfl::Box, "
+          "std::shared_ptr, or"
+          "rfl::Ref instead."
         );
         return Error("Unsupported.");
       }
 
       template <class P>
-      static void write(
-          const W&                        _w,
-          const std::reference_wrapper<T> _ref,
-          const P&                        _p
-      ) noexcept {
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, _ref.get(), _p
-        );
+      static void write(const W& _w, const std::reference_wrapper<T> _ref, const P& _p) noexcept {
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, _ref.get(), _p);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_rename.hpp b/include/rfl/parsing/Parser_rename.hpp
index dc17616..dcc3d88 100644
--- a/include/rfl/parsing/Parser_rename.hpp
+++ b/include/rfl/parsing/Parser_rename.hpp
@@ -14,45 +14,26 @@
 namespace rfl {
   namespace parsing {
 
-    template <
-        class R,
-        class W,
-        class T,
-        internal::StringLiteral _name,
-        class ProcessorsType>
+    template <class R, class W, class T, internal::StringLiteral _name, class ProcessorsType>
       requires AreReaderAndWriter<R, W, Rename<_name, T>>
     struct Parser<R, W, Rename<_name, T>, ProcessorsType> {
       using InputVarType  = typename R::InputVarType;
       using OutputVarType = typename W::OutputVarType;
 
-      static Result<Rename<_name, T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
-        const auto to_rename = [](auto&& _t) {
-          return Rename<_name, T>(std::move(_t));
-        };
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                   _r, _var
-        )
-            .transform(to_rename);
+      static Result<Rename<_name, T>> read(const R& _r, const InputVarType& _var) noexcept {
+        const auto to_rename = [](auto&& _t) { return Rename<_name, T>(std::move(_t)); };
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(
+          to_rename
+        );
       }
 
       template <class P>
-      static void write(
-          const W&                _w,
-          const Rename<_name, T>& _rename,
-          const P&                _parent
-      ) noexcept {
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, _rename.value(), _parent
-        );
+      static void write(const W& _w, const Rename<_name, T>& _rename, const P& _parent) noexcept {
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, _rename.value(), _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_result.hpp b/include/rfl/parsing/Parser_result.hpp
index 857dd71..417232d 100644
--- a/include/rfl/parsing/Parser_result.hpp
+++ b/include/rfl/parsing/Parser_result.hpp
@@ -22,8 +22,7 @@ namespace rfl {
       using ErrorType   = NamedTuple<Field<"error", std::string>>;
       using VariantType = std::variant<std::remove_cvref_t<T>, ErrorType>;
 
-      static Result<Result<T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<Result<T>> read(const R& _r, const InputVarType& _var) noexcept {
         const auto handle = [](auto&& _t) -> Result<T> {
           using Type = std::remove_cvref_t<decltype(_t)>;
           if constexpr (std::is_same<Type, ErrorType>()) {
@@ -38,25 +37,20 @@ namespace rfl {
         };
 
         return Result<Result<T>>(
-            Parser<R, W, VariantType, ProcessorsType>::read(_r, _var).transform(
-                to_res
-            )
+          Parser<R, W, VariantType, ProcessorsType>::read(_r, _var).transform(to_res)
         );
       }
 
       template <class P>
-      static void
-      write(const W& _w, const Result<T>& _r, const P& _parent) noexcept {
+      static void write(const W& _w, const Result<T>& _r, const P& _parent) noexcept {
         const auto write_t = [&](const auto& _t) -> Nothing {
-          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-              _w, _t, _parent
-          );
+          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, _t, _parent);
           return Nothing {};
         };
 
         const auto write_err = [&](const auto& _err) -> Nothing {
           Parser<R, W, ErrorType, ProcessorsType>::write(
-              _w, ErrorType(make_field<"error">(_err.what())), _parent
+            _w, ErrorType(make_field<"error">(_err.what())), _parent
           );
           return Nothing {};
         };
@@ -64,12 +58,8 @@ namespace rfl {
         _r.transform(write_t).or_else(write_err);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_rfl_array.hpp b/include/rfl/parsing/Parser_rfl_array.hpp
index fd8ae4c..ad40f72 100644
--- a/include/rfl/parsing/Parser_rfl_array.hpp
+++ b/include/rfl/parsing/Parser_rfl_array.hpp
@@ -27,23 +27,16 @@ namespace rfl {
 
       using StdArray = internal::to_std_array_t<T>;
 
-      static Result<internal::Array<T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<internal::Array<T>> read(const R& _r, const InputVarType& _var) noexcept {
         return Parser<R, W, StdArray, ProcessorsType>::read(_r, _var);
       }
 
       template <class P>
-      static void write(
-          const W&                  _w,
-          const internal::Array<T>& _arr,
-          const P&                  _parent
-      ) noexcept {
+      static void write(const W& _w, const internal::Array<T>& _arr, const P& _parent) noexcept {
         Parser<R, W, StdArray, ProcessorsType>::write(_w, _arr.arr_, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         return Parser<R, W, StdArray, ProcessorsType>::to_schema(_definitions);
       }
     };
diff --git a/include/rfl/parsing/Parser_rfl_variant.hpp b/include/rfl/parsing/Parser_rfl_variant.hpp
index e91aa0b..ff342d5 100644
--- a/include/rfl/parsing/Parser_rfl_variant.hpp
+++ b/include/rfl/parsing/Parser_rfl_variant.hpp
@@ -25,32 +25,23 @@ namespace rfl {
       static Result<rfl::Variant<FieldTypes...>>
       read(const R& _r, const InputVarType& _var) noexcept {
         const auto to_rfl_variant = [](auto&& _var) {
-          return rfl::Variant<FieldTypes...>(
-              std::forward<std::variant<FieldTypes...>>(_var)
-          );
+          return rfl::Variant<FieldTypes...>(std::forward<std::variant<FieldTypes...>>(_var));
         };
-        return Parser<R, W, std::variant<FieldTypes...>, ProcessorsType>::read(
-                   _r, _var
-        )
-            .transform(to_rfl_variant);
-      }
-
-      template <class P>
-      static void write(
-          const W&                           _w,
-          const rfl::Variant<FieldTypes...>& _variant,
-          const P&                           _parent
-      ) noexcept {
-        Parser<R, W, std::variant<FieldTypes...>, ProcessorsType>::write(
-            _w, _variant.variant(), _parent
+        return Parser<R, W, std::variant<FieldTypes...>, ProcessorsType>::read(_r, _var).transform(
+          to_rfl_variant
         );
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::variant<FieldTypes...>, ProcessorsType>::
-            to_schema(_definitions);
+      template <class P>
+      static void
+      write(const W& _w, const rfl::Variant<FieldTypes...>& _variant, const P& _parent) noexcept {
+        Parser<R, W, std::variant<FieldTypes...>, ProcessorsType>::write(
+          _w, _variant.variant(), _parent
+        );
+      }
+
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::variant<FieldTypes...>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_shared_ptr.hpp b/include/rfl/parsing/Parser_shared_ptr.hpp
index 010b1d6..3b73712 100644
--- a/include/rfl/parsing/Parser_shared_ptr.hpp
+++ b/include/rfl/parsing/Parser_shared_ptr.hpp
@@ -22,42 +22,27 @@ namespace rfl::parsing {
 
     using ParentType = Parent<W>;
 
-    static Result<std::shared_ptr<T>>
-    read(const R& _r, const InputVarType& _var) noexcept {
+    static Result<std::shared_ptr<T>> read(const R& _r, const InputVarType& _var) noexcept {
       if (_r.is_empty(_var)) {
         return std::shared_ptr<T>();
       }
-      const auto to_ptr = [](auto&& _t) {
-        return std::make_shared<T>(std::move(_t));
-      };
-      return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                 _r, _var
-      )
-          .transform(to_ptr);
+      const auto to_ptr = [](auto&& _t) { return std::make_shared<T>(std::move(_t)); };
+      return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(to_ptr);
     }
 
     template <class P>
-    static void write(
-        const W&                  _w,
-        const std::shared_ptr<T>& _s,
-        const P&                  _parent
-    ) noexcept {
+    static void write(const W& _w, const std::shared_ptr<T>& _s, const P& _parent) noexcept {
       if (!_s) {
         ParentType::add_null(_w, _parent);
         return;
       }
-      Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-          _w, *_s, _parent
-      );
+      Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, *_s, _parent);
     }
 
-    static schema::Type to_schema(
-        std::map<std::string, schema::Type>* _definitions
-    ) {
+    static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
       using U = std::remove_cvref_t<T>;
-      return schema::Type {schema::Type::Optional {Ref<schema::Type>::make(
-          Parser<R, W, U, ProcessorsType>::to_schema(_definitions)
-      )}};
+      return schema::Type { schema::Type::Optional {
+        Ref<schema::Type>::make(Parser<R, W, U, ProcessorsType>::to_schema(_definitions)) } };
     }
   };
 
diff --git a/include/rfl/parsing/Parser_skip.hpp b/include/rfl/parsing/Parser_skip.hpp
index 88ec4ad..cd6489b 100644
--- a/include/rfl/parsing/Parser_skip.hpp
+++ b/include/rfl/parsing/Parser_skip.hpp
@@ -14,72 +14,57 @@ namespace rfl {
   namespace parsing {
 
     template <
-        class R,
-        class W,
-        class T,
-        bool _skip_serialization,
-        bool _skip_deserialization,
-        class ProcessorsType>
+      class R,
+      class W,
+      class T,
+      bool _skip_serialization,
+      bool _skip_deserialization,
+      class ProcessorsType>
       requires AreReaderAndWriter<
-          R,
-          W,
-          internal::Skip<T, _skip_serialization, _skip_deserialization>>
-    struct Parser<
         R,
         W,
-        internal::Skip<T, _skip_serialization, _skip_deserialization>,
-        ProcessorsType> {
+        internal::Skip<T, _skip_serialization, _skip_deserialization>>
+    struct Parser<
+      R,
+      W,
+      internal::Skip<T, _skip_serialization, _skip_deserialization>,
+      ProcessorsType> {
       using InputVarType  = typename R::InputVarType;
       using OutputVarType = typename W::OutputVarType;
 
-      static Result<
-          internal::Skip<T, _skip_serialization, _skip_deserialization>>
+      static Result<internal::Skip<T, _skip_serialization, _skip_deserialization>>
       read(const R& _r, const InputVarType& _var) noexcept {
         if constexpr (_skip_deserialization) {
           return internal::Skip<T, _skip_serialization, _skip_deserialization>(
-              std::remove_cvref_t<T>()
+            std::remove_cvref_t<T>()
           );
         } else {
           const auto to_skip = [&](auto&& _t) {
-            return internal::
-                Skip<T, _skip_serialization, _skip_deserialization>(std::move(_t
-                ));
+            return internal::Skip<T, _skip_serialization, _skip_deserialization>(std::move(_t));
           };
-          return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                     _r, _var
-          )
-              .transform(to_skip);
+          return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(
+            to_skip
+          );
         }
       }
 
       template <class P>
       static void write(
-          const W& _w,
-          const internal::Skip<T, _skip_serialization, _skip_deserialization>&
-                   _skip,
-          const P& _parent
+        const W&                                                             _w,
+        const internal::Skip<T, _skip_serialization, _skip_deserialization>& _skip,
+        const P&                                                             _parent
       ) noexcept {
         if constexpr (_skip_serialization) {
-          using ReflectionType = std::remove_cvref_t<typename internal::Skip<
-              T,
-              _skip_serialization,
-              _skip_deserialization>::ReflectionType>;
-          Parser<R, W, ReflectionType, ProcessorsType>::write(
-              _w, ReflectionType(), _parent
-          );
+          using ReflectionType = std::remove_cvref_t<
+            typename internal::Skip<T, _skip_serialization, _skip_deserialization>::ReflectionType>;
+          Parser<R, W, ReflectionType, ProcessorsType>::write(_w, ReflectionType(), _parent);
         } else {
-          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-              _w, _skip.value(), _parent
-          );
+          Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, _skip.value(), _parent);
         }
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(
-            _definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_string_view.hpp b/include/rfl/parsing/Parser_string_view.hpp
index 6e82772..8ceb1d0 100644
--- a/include/rfl/parsing/Parser_string_view.hpp
+++ b/include/rfl/parsing/Parser_string_view.hpp
@@ -20,30 +20,23 @@ namespace rfl {
       using InputVarType  = typename R::InputVarType;
       using OutputVarType = typename W::OutputVarType;
 
-      static Result<std::string_view>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<std::string_view> read(const R& _r, const InputVarType& _var) noexcept {
         static_assert(
-            always_false_v<R>,
-            "Reading into std::string_view is dangerous and "
-            "therefore unsupported. "
-            "Please consider using std::string instead."
+          always_false_v<R>,
+          "Reading into std::string_view is dangerous and "
+          "therefore unsupported. "
+          "Please consider using std::string instead."
         );
         return Error("Unsupported.");
       }
 
       template <class P>
-      static void
-      write(const W& _w, const std::string_view& _str, const P& _p) noexcept {
-        Parser<R, W, std::string_view, ProcessorsType>::write(
-            _w, std::string(_str), _p
-        );
+      static void write(const W& _w, const std::string_view& _str, const P& _p) noexcept {
+        Parser<R, W, std::string_view, ProcessorsType>::write(_w, std::string(_str), _p);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::string, ProcessorsType>::to_schema(_definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::string, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/Parser_tagged_union.hpp b/include/rfl/parsing/Parser_tagged_union.hpp
index c1155d3..51b5841 100644
--- a/include/rfl/parsing/Parser_tagged_union.hpp
+++ b/include/rfl/parsing/Parser_tagged_union.hpp
@@ -16,22 +16,14 @@ namespace rfl {
   namespace parsing {
 
     template <
-        class R,
-        class W,
-        internal::StringLiteral _discriminator,
-        class... AlternativeTypes,
-        class ProcessorsType>
-      requires AreReaderAndWriter<
-          R,
-          W,
-          TaggedUnion<_discriminator, AlternativeTypes...>>
-    struct Parser<
-        R,
-        W,
-        TaggedUnion<_discriminator, AlternativeTypes...>,
-        ProcessorsType> {
-      using ResultType =
-          Result<TaggedUnion<_discriminator, AlternativeTypes...>>;
+      class R,
+      class W,
+      internal::StringLiteral _discriminator,
+      class... AlternativeTypes,
+      class ProcessorsType>
+      requires AreReaderAndWriter<R, W, TaggedUnion<_discriminator, AlternativeTypes...>>
+    struct Parser<R, W, TaggedUnion<_discriminator, AlternativeTypes...>, ProcessorsType> {
+      using ResultType = Result<TaggedUnion<_discriminator, AlternativeTypes...>>;
 
      public:
       using InputObjectType = typename R::InputObjectType;
@@ -41,9 +33,7 @@ namespace rfl {
       using OutputVarType    = typename W::OutputVarType;
 
       static ResultType read(const R& _r, const InputVarType& _var) noexcept {
-        const auto get_disc = [&_r](auto _obj) {
-          return get_discriminator(_r, _obj);
-        };
+        const auto get_disc = [&_r](auto _obj) { return get_discriminator(_r, _obj); };
 
         const auto to_result = [&_r, _var](const std::string& _disc_value) {
           return find_matching_alternative(_r, _disc_value, _var);
@@ -54,65 +44,55 @@ namespace rfl {
 
       template <class P>
       static void write(
-          const W&                                                _w,
-          const TaggedUnion<_discriminator, AlternativeTypes...>& _tagged_union,
-          const P&                                                _parent
+        const W&                                                _w,
+        const TaggedUnion<_discriminator, AlternativeTypes...>& _tagged_union,
+        const P&                                                _parent
       ) noexcept {
-        const auto handle = [&](const auto& _val) {
-          write_wrapped(_w, _val, _parent);
-        };
+        const auto handle = [&](const auto& _val) { write_wrapped(_w, _val, _parent); };
         std::visit(handle, _tagged_union.variant_);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        using VariantType = std::variant<std::invoke_result_t<
-            decltype(wrap_if_necessary<AlternativeTypes>),
-            AlternativeTypes>...>;
-        return Parser<R, W, VariantType, ProcessorsType>::to_schema(_definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        using VariantType = std::variant<
+          std::invoke_result_t<decltype(wrap_if_necessary<AlternativeTypes>), AlternativeTypes>...>;
+        return Parser<R, W, VariantType, ProcessorsType>::to_schema(_definitions);
       }
 
      private:
       template <int _i = 0>
       static ResultType find_matching_alternative(
-          const R&            _r,
-          const std::string&  _disc_value,
-          const InputVarType& _var
+        const R&            _r,
+        const std::string&  _disc_value,
+        const InputVarType& _var
       ) noexcept {
         if constexpr (_i == sizeof...(AlternativeTypes)) {
-          const auto names = TaggedUnion<_discriminator, AlternativeTypes...>::
-              PossibleTags::names();
+          const auto names =
+            TaggedUnion<_discriminator, AlternativeTypes...>::PossibleTags::names();
           return Error(
-              "Could not parse tagged union, could not match " +
-              _discriminator.str() + " '" + _disc_value +
-              "'. The following tags are allowed: " +
-              internal::strings::join(",", names)
+            "Could not parse tagged union, could not match " + _discriminator.str() + " '" +
+            _disc_value +
+            "'. The following tags are allowed: " + internal::strings::join(",", names)
           );
         } else {
-          using AlternativeType = std::remove_cvref_t<
-              std::
-                  variant_alternative_t<_i, std::variant<AlternativeTypes...>>>;
+          using AlternativeType =
+            std::remove_cvref_t<std::variant_alternative_t<_i, std::variant<AlternativeTypes...>>>;
 
           if (contains_disc_value<AlternativeType>(_disc_value)) {
             const auto to_tagged_union = [](auto&& _val) {
-              return TaggedUnion<_discriminator, AlternativeTypes...>(
-                  std::move(_val)
-              );
+              return TaggedUnion<_discriminator, AlternativeTypes...>(std::move(_val));
             };
 
             const auto embellish_error = [&](Error&& _e) {
               return Error(
-                  "Could not parse tagged union with "
-                  "discrimininator " +
-                  _discriminator.str() + " '" + _disc_value + "': " + _e.what()
+                "Could not parse tagged union with "
+                "discrimininator " +
+                _discriminator.str() + " '" + _disc_value + "': " + _e.what()
               );
             };
 
             return Parser<R, W, AlternativeType, ProcessorsType>::read(_r, _var)
-                .transform(to_tagged_union)
-                .or_else(embellish_error);
+              .transform(to_tagged_union)
+              .or_else(embellish_error);
 
           } else {
             return find_matching_alternative<_i + 1>(_r, _disc_value, _var);
@@ -125,8 +105,8 @@ namespace rfl {
       get_discriminator(const R& _r, const InputObjectType& _obj) noexcept {
         const auto embellish_error = [](const auto& _err) {
           return Error(
-              "Could not parse tagged union: Could not find field '" +
-              _discriminator.str() + "' or type of field was not a string."
+            "Could not parse tagged union: Could not find field '" + _discriminator.str() +
+            "' or type of field was not a string."
           );
         };
 
@@ -134,47 +114,41 @@ namespace rfl {
           return _r.template to_basic_type<std::string>(_var);
         };
 
-        return _r.get_field(_discriminator.str(), _obj)
-            .and_then(to_type)
-            .or_else(embellish_error);
+        return _r.get_field(_discriminator.str(), _obj).and_then(to_type).or_else(embellish_error);
       }
 
       /// Determines whether the discriminating literal contains the value
       /// retrieved from the object.
       template <class T>
-      static inline bool contains_disc_value(const std::string& _disc_value
-      ) noexcept {
+      static inline bool contains_disc_value(const std::string& _disc_value) noexcept {
         return internal::tag_t<_discriminator, T>::contains(_disc_value);
       }
 
       /// Writes a wrapped version of the original object, which contains the
       /// tag.
       template <class T, class P>
-      static void
-      write_wrapped(const W& _w, const T& _val, const P& _parent) noexcept {
+      static void write_wrapped(const W& _w, const T& _val, const P& _parent) noexcept {
         const auto wrapped = wrap_if_necessary(_val);
-        Parser<R, W, std::remove_cvref_t<decltype(wrapped)>, ProcessorsType>::
-            write(_w, wrapped, _parent);
+        Parser<R, W, std::remove_cvref_t<decltype(wrapped)>, ProcessorsType>::write(
+          _w, wrapped, _parent
+        );
       }
 
       /// Generates a wrapped version of the original object, which contains the
       /// tag, if the object doesn't already contain the wrap.
       template <class T>
       static auto wrap_if_necessary(const T& _val) noexcept {
-        if constexpr (named_tuple_t<T>::Names::template contains<
-                          _discriminator>()) {
+        if constexpr (named_tuple_t<T>::Names::template contains<_discriminator>()) {
           return _val;
         } else {
           const auto tag = internal::make_tag<_discriminator, T>(_val);
           using TagType  = std::remove_cvref_t<decltype(tag)>;
           if constexpr (internal::has_fields<std::remove_cvref_t<T>>()) {
-            using WrapperType =
-                TaggedUnionWrapperWithFields<T, TagType, _discriminator>;
-            return WrapperType {.tag = tag, .fields = &_val};
+            using WrapperType = TaggedUnionWrapperWithFields<T, TagType, _discriminator>;
+            return WrapperType { .tag = tag, .fields = &_val };
           } else {
-            using WrapperType =
-                TaggedUnionWrapperNoFields<T, TagType, _discriminator>;
-            return WrapperType {.tag = tag, .fields = &_val};
+            using WrapperType = TaggedUnionWrapperNoFields<T, TagType, _discriminator>;
+            return WrapperType { .tag = tag, .fields = &_val };
           }
         }
       }
diff --git a/include/rfl/parsing/Parser_tuple.hpp b/include/rfl/parsing/Parser_tuple.hpp
index c06af29..f0192e2 100644
--- a/include/rfl/parsing/Parser_tuple.hpp
+++ b/include/rfl/parsing/Parser_tuple.hpp
@@ -10,13 +10,13 @@ namespace rfl {
     template <class R, class W, class... Ts, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::tuple<Ts...>>
     struct Parser<R, W, std::tuple<Ts...>, ProcessorsType>
-        : public TupleParser<
-              R,
-              W,
-              /*_ignore_empty_containers=*/false,
-              /*_all_required=*/ProcessorsType::all_required_,
-              ProcessorsType,
-              Ts...> {};
+      : public TupleParser<
+          R,
+          W,
+          /*_ignore_empty_containers=*/false,
+          /*_all_required=*/ProcessorsType::all_required_,
+          ProcessorsType,
+          Ts...> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/Parser_unique_ptr.hpp b/include/rfl/parsing/Parser_unique_ptr.hpp
index dd66633..bbffb54 100644
--- a/include/rfl/parsing/Parser_unique_ptr.hpp
+++ b/include/rfl/parsing/Parser_unique_ptr.hpp
@@ -23,42 +23,28 @@ namespace rfl {
 
       using ParentType = Parent<W>;
 
-      static Result<std::unique_ptr<T>>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<std::unique_ptr<T>> read(const R& _r, const InputVarType& _var) noexcept {
         if (_r.is_empty(_var)) {
           return std::unique_ptr<T>();
         }
-        const auto to_ptr = [](auto&& _t) {
-          return std::make_unique<T>(std::move(_t));
-        };
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-                   _r, _var
-        )
-            .transform(to_ptr);
+        const auto to_ptr = [](auto&& _t) { return std::make_unique<T>(std::move(_t)); };
+        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var).transform(to_ptr
+        );
       }
 
       template <class P>
-      static void write(
-          const W&                  _w,
-          const std::unique_ptr<T>& _s,
-          const P&                  _parent
-      ) noexcept {
+      static void write(const W& _w, const std::unique_ptr<T>& _s, const P& _parent) noexcept {
         if (!_s) {
           ParentType::add_null(_w, _parent);
           return;
         }
-        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-            _w, *_s, _parent
-        );
+        Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, *_s, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         using U = std::remove_cvref_t<T>;
-        return schema::Type {schema::Type::Optional {Ref<schema::Type>::make(
-            Parser<R, W, U, ProcessorsType>::to_schema(_definitions)
-        )}};
+        return schema::Type { schema::Type::Optional {
+          Ref<schema::Type>::make(Parser<R, W, U, ProcessorsType>::to_schema(_definitions)) } };
       }
     };
 
diff --git a/include/rfl/parsing/Parser_variant.hpp b/include/rfl/parsing/Parser_variant.hpp
index 418633a..cc07edf 100644
--- a/include/rfl/parsing/Parser_variant.hpp
+++ b/include/rfl/parsing/Parser_variant.hpp
@@ -27,9 +27,7 @@ namespace rfl {
       static Result<std::variant<FieldTypes...>>
       read(const R& _r, const InputVarType& _var) noexcept {
         if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
-          return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::read(
-              _r, _var
-          );
+          return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::read(_r, _var);
         } else {
           std::optional<std::variant<FieldTypes...>> result;
           std::vector<Error>                         errors;
@@ -38,26 +36,21 @@ namespace rfl {
             return std::move(*result);
           } else {
             return Error(to_single_error_message(
-                errors,
-                "Could not parse the variant. Each of the "
-                "possible alternatives failed "
-                "for the following reasons: ",
-                100000
+              errors,
+              "Could not parse the variant. Each of the "
+              "possible alternatives failed "
+              "for the following reasons: ",
+              100000
             ));
           }
         }
       }
 
       template <class P>
-      static void write(
-          const W&                           _w,
-          const std::variant<FieldTypes...>& _variant,
-          const P&                           _parent
-      ) noexcept {
+      static void
+      write(const W& _w, const std::variant<FieldTypes...>& _variant, const P& _parent) noexcept {
         if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
-          FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::write(
-              _w, _variant, _parent
-          );
+          FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::write(_w, _variant, _parent);
         } else {
           const auto handle = [&](const auto& _v) {
             using Type = std::remove_cvref_t<decltype(_v)>;
@@ -69,23 +62,20 @@ namespace rfl {
 
       template <size_t _i = 0>
       static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions,
-          std::vector<schema::Type>            _types = {}
+        std::map<std::string, schema::Type>* _definitions,
+        std::vector<schema::Type>            _types = {}
       ) {
         if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
-          return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::
-              to_schema(_definitions);
+          return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::to_schema(_definitions);
         } else {
           using Type            = schema::Type;
           constexpr size_t size = sizeof...(FieldTypes);
           if constexpr (_i == size) {
-            return Type {Type::AnyOf {.types_ = _types}};
+            return Type { Type::AnyOf { .types_ = _types } };
           } else {
-            using U = std::remove_cvref_t<
-                std::variant_alternative_t<_i, std::variant<FieldTypes...>>>;
-            _types.push_back(
-                Parser<R, W, U, ProcessorsType>::to_schema(_definitions)
-            );
+            using U =
+              std::remove_cvref_t<std::variant_alternative_t<_i, std::variant<FieldTypes...>>>;
+            _types.push_back(Parser<R, W, U, ProcessorsType>::to_schema(_definitions));
             return to_schema<_i + 1>(_definitions, std::move(_types));
           }
         }
@@ -94,15 +84,15 @@ namespace rfl {
      private:
       template <int _i = 0>
       static void read_variant(
-          const R&                                    _r,
-          const InputVarType&                         _var,
-          std::optional<std::variant<FieldTypes...>>* _result,
-          std::vector<Error>*                         _errors
+        const R&                                    _r,
+        const InputVarType&                         _var,
+        std::optional<std::variant<FieldTypes...>>* _result,
+        std::vector<Error>*                         _errors
       ) noexcept {
         constexpr size_t size = sizeof...(FieldTypes);
         if constexpr (_i < size) {
-          using AltType = std::remove_cvref_t<
-              std::variant_alternative_t<_i, std::variant<FieldTypes...>>>;
+          using AltType =
+            std::remove_cvref_t<std::variant_alternative_t<_i, std::variant<FieldTypes...>>>;
           auto res = Parser<R, W, AltType, ProcessorsType>::read(_r, _var);
           if (res) {
             *_result = std::move(*res);
diff --git a/include/rfl/parsing/Parser_vector_like.hpp b/include/rfl/parsing/Parser_vector_like.hpp
index d6aa8b0..d49830c 100644
--- a/include/rfl/parsing/Parser_vector_like.hpp
+++ b/include/rfl/parsing/Parser_vector_like.hpp
@@ -24,71 +24,62 @@ namespace rfl {
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::deque<T>>
     struct Parser<R, W, std::deque<T>, ProcessorsType>
-        : public VectorParser<R, W, std::deque<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::deque<T>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::forward_list<T>>
     struct Parser<R, W, std::forward_list<T>, ProcessorsType>
-        : public VectorParser<R, W, std::forward_list<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::forward_list<T>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::list<T>>
     struct Parser<R, W, std::list<T>, ProcessorsType>
-        : public VectorParser<R, W, std::list<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::list<T>, ProcessorsType> {};
 
     template <class R, class W, class K, class V, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::map<K, V>>
     struct Parser<R, W, std::map<K, V>, ProcessorsType>
-        : public VectorParser<R, W, std::map<K, V>, ProcessorsType> {};
+      : public VectorParser<R, W, std::map<K, V>, ProcessorsType> {};
 
     template <class R, class W, class K, class V, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::multimap<K, V>>
     struct Parser<R, W, std::multimap<K, V>, ProcessorsType>
-        : public VectorParser<R, W, std::multimap<K, V>, ProcessorsType> {};
+      : public VectorParser<R, W, std::multimap<K, V>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::multiset<T>>
     struct Parser<R, W, std::multiset<T>, ProcessorsType>
-        : public VectorParser<R, W, std::multiset<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::multiset<T>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::set<T>>
     struct Parser<R, W, std::set<T>, ProcessorsType>
-        : public VectorParser<R, W, std::set<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::set<T>, ProcessorsType> {};
 
     template <class R, class W, class K, class V, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::unordered_map<K, V>>
     struct Parser<R, W, std::unordered_map<K, V>, ProcessorsType>
-        : public VectorParser<R, W, std::unordered_map<K, V>, ProcessorsType> {
-    };
+      : public VectorParser<R, W, std::unordered_map<K, V>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::unordered_multiset<T>>
     struct Parser<R, W, std::unordered_multiset<T>, ProcessorsType>
-        : public VectorParser<
-              R,
-              W,
-              std::unordered_multiset<T>,
-              ProcessorsType> {};
+      : public VectorParser<R, W, std::unordered_multiset<T>, ProcessorsType> {};
 
     template <class R, class W, class K, class V, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::unordered_multimap<K, V>>
     struct Parser<R, W, std::unordered_multimap<K, V>, ProcessorsType>
-        : public VectorParser<
-              R,
-              W,
-              std::unordered_multimap<K, V>,
-              ProcessorsType> {};
+      : public VectorParser<R, W, std::unordered_multimap<K, V>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::unordered_set<T>>
     struct Parser<R, W, std::unordered_set<T>, ProcessorsType>
-        : public VectorParser<R, W, std::unordered_set<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::unordered_set<T>, ProcessorsType> {};
 
     template <class R, class W, class T, class ProcessorsType>
       requires AreReaderAndWriter<R, W, std::vector<T>>
     struct Parser<R, W, std::vector<T>, ProcessorsType>
-        : public VectorParser<R, W, std::vector<T>, ProcessorsType> {};
+      : public VectorParser<R, W, std::vector<T>, ProcessorsType> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/Parser_wstring.hpp b/include/rfl/parsing/Parser_wstring.hpp
index 475e42b..ddb994a 100644
--- a/include/rfl/parsing/Parser_wstring.hpp
+++ b/include/rfl/parsing/Parser_wstring.hpp
@@ -22,8 +22,7 @@ namespace rfl {
 
       using ParentType = Parent<W>;
 
-      static Result<std::wstring>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<std::wstring> read(const R& _r, const InputVarType& _var) noexcept {
         if (_r.is_empty(_var)) {
           return std::wstring();
         }
@@ -51,8 +50,7 @@ namespace rfl {
       }
 
       template <class P>
-      static void
-      write(const W& _w, const std::wstring& _str, const P& _parent) noexcept {
+      static void write(const W& _w, const std::wstring& _str, const P& _parent) noexcept {
         if (_str.empty()) {
           ParentType::add_value(_w, std::string(), _parent);
           return;
@@ -69,11 +67,8 @@ namespace rfl {
         ParentType::add_value(_w, outStr, _parent);
       }
 
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
-        return Parser<R, W, std::string, ProcessorsType>::to_schema(_definitions
-        );
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
+        return Parser<R, W, std::string, ProcessorsType>::to_schema(_definitions);
       }
     };
 
diff --git a/include/rfl/parsing/TupleParser.hpp b/include/rfl/parsing/TupleParser.hpp
index de599b0..ea74a6d 100644
--- a/include/rfl/parsing/TupleParser.hpp
+++ b/include/rfl/parsing/TupleParser.hpp
@@ -14,12 +14,12 @@
 namespace rfl::parsing {
 
   template <
-      class R,
-      class W,
-      bool _ignore_empty_containers,
-      bool _all_required,
-      class ProcessorsType,
-      class... Ts>
+    class R,
+    class W,
+    bool _ignore_empty_containers,
+    bool _all_required,
+    class ProcessorsType,
+    class... Ts>
     requires AreReaderAndWriter<R, W, std::tuple<Ts...>>
   struct TupleParser {
    public:
@@ -31,19 +31,17 @@ namespace rfl::parsing {
 
     using ParentType = Parent<W>;
 
-    static Result<std::tuple<Ts...>>
-    read(const R& _r, const InputVarType& _var) noexcept {
-      const auto parse = [&](const InputArrayType& _arr
-                         ) -> Result<std::tuple<Ts...>> {
+    static Result<std::tuple<Ts...>> read(const R& _r, const InputVarType& _var) noexcept {
+      const auto parse = [&](const InputArrayType& _arr) -> Result<std::tuple<Ts...>> {
         alignas(std::tuple<Ts...>) unsigned char buf[sizeof(std::tuple<Ts...>)];
-        auto       ptr          = reinterpret_cast<std::tuple<Ts...>*>(buf);
-        const auto tuple_reader = TupleReader<
-            R,
-            W,
-            std::tuple<Ts...>,
-            _ignore_empty_containers,
-            _all_required,
-            ProcessorsType>(&_r, ptr);
+        auto                                     ptr = reinterpret_cast<std::tuple<Ts...>*>(buf);
+        const auto                               tuple_reader = TupleReader<
+                                        R,
+                                        W,
+                                        std::tuple<Ts...>,
+                                        _ignore_empty_containers,
+                                        _all_required,
+                                        ProcessorsType>(&_r, ptr);
         auto err = _r.read_array(tuple_reader, _arr);
         if (err) {
           tuple_reader.call_destructors_where_necessary();
@@ -61,48 +59,36 @@ namespace rfl::parsing {
     }
 
     template <class P>
-    static void write(
-        const W&                 _w,
-        const std::tuple<Ts...>& _tup,
-        const P&                 _parent
-    ) noexcept {
+    static void write(const W& _w, const std::tuple<Ts...>& _tup, const P& _parent) noexcept {
       auto       arr        = ParentType::add_array(_w, sizeof...(Ts), _parent);
-      const auto new_parent = typename ParentType::Array {&arr};
+      const auto new_parent = typename ParentType::Array { &arr };
       to_array<0>(_w, _tup, new_parent);
       _w.end_array(&arr);
     }
 
     template <size_t _i = 0>
     static schema::Type to_schema(
-        std::map<std::string, schema::Type>* _definitions,
-        std::vector<schema::Type>            _types = {}
+      std::map<std::string, schema::Type>* _definitions,
+      std::vector<schema::Type>            _types = {}
     ) {
       using Type            = schema::Type;
       constexpr size_t size = sizeof...(Ts);
       if constexpr (_i == size) {
-        return Type {Type::Tuple {.types_ = _types}};
+        return Type { Type::Tuple { .types_ = _types } };
       } else {
-        using U =
-            std::remove_cvref_t<std::tuple_element_t<_i, std::tuple<Ts...>>>;
-        _types.push_back(Parser<R, W, U, ProcessorsType>::to_schema(_definitions
-        ));
+        using U = std::remove_cvref_t<std::tuple_element_t<_i, std::tuple<Ts...>>>;
+        _types.push_back(Parser<R, W, U, ProcessorsType>::to_schema(_definitions));
         return to_schema<_i + 1>(_definitions, std::move(_types));
       }
     }
 
    private:
     template <int _i, class P>
-    static void to_array(
-        const W&                 _w,
-        const std::tuple<Ts...>& _tup,
-        const P&                 _parent
-    ) noexcept {
+    static void to_array(const W& _w, const std::tuple<Ts...>& _tup, const P& _parent) noexcept {
       if constexpr (_i < sizeof...(Ts)) {
-        using NewFieldType = std::remove_cvref_t<
-            typename std::tuple_element_t<_i, std::tuple<Ts...>>>;
-        Parser<R, W, NewFieldType, ProcessorsType>::write(
-            _w, std::get<_i>(_tup), _parent
-        );
+        using NewFieldType =
+          std::remove_cvref_t<typename std::tuple_element_t<_i, std::tuple<Ts...>>>;
+        Parser<R, W, NewFieldType, ProcessorsType>::write(_w, std::get<_i>(_tup), _parent);
         to_array<_i + 1>(_w, _tup, _parent);
       }
     }
diff --git a/include/rfl/parsing/TupleReader.hpp b/include/rfl/parsing/TupleReader.hpp
index e6be37c..02276b5 100644
--- a/include/rfl/parsing/TupleReader.hpp
+++ b/include/rfl/parsing/TupleReader.hpp
@@ -12,20 +12,19 @@
 namespace rfl::parsing {
 
   template <
-      class R,
-      class W,
-      class TupleType,
-      bool _ignore_empty_containers,
-      bool _all_required,
-      class ProcessorsType>
+    class R,
+    class W,
+    class TupleType,
+    bool _ignore_empty_containers,
+    bool _all_required,
+    class ProcessorsType>
   class TupleReader {
    private:
     using InputVarType            = typename R::InputVarType;
     static constexpr size_t size_ = std::tuple_size_v<TupleType>;
 
    public:
-    TupleReader(const R* _r, TupleType* _tuple)
-        : i_(0), r_(_r), tuple_(_tuple) {}
+    TupleReader(const R* _r, TupleType* _tuple) : i_(0), r_(_r), tuple_(_tuple) {}
 
     ~TupleReader() = default;
 
@@ -51,10 +50,8 @@ namespace rfl::parsing {
         if (_i >= i_) {
           return;
         }
-        using CurrentType =
-            std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
-        if constexpr (!std::is_array_v<CurrentType> &&
-                      std::is_pointer_v<CurrentType> &&
+        using CurrentType = std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
+        if constexpr (!std::is_array_v<CurrentType> && std::is_pointer_v<CurrentType> &&
                       std::is_destructible_v<CurrentType>) {
           std::get<_i>(*tuple_)->~CurrentType();
         } else if constexpr (std::is_array_v<CurrentType>) {
@@ -70,14 +67,10 @@ namespace rfl::parsing {
     void handle_missing_fields_impl(std::optional<Error>* _err) const noexcept {
       if constexpr (_i < size_) {
         if (i_ == _i) {
-          using CurrentType =
-              std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
+          using CurrentType = std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
 
-          if constexpr (_all_required ||
-                        is_required<CurrentType, _ignore_empty_containers>()) {
-            *_err = Error(
-                "Field " + std::to_string(_i) + " was required, but missing."
-            );
+          if constexpr (_all_required || is_required<CurrentType, _ignore_empty_containers>()) {
+            *_err = Error("Field " + std::to_string(_i) + " was required, but missing.");
             return;
           } else {
             ::new (&(std::get<_i>(*tuple_))) CurrentType();
@@ -92,8 +85,7 @@ namespace rfl::parsing {
     void read_impl(const InputVarType& _var, std::optional<Error>* _err) const {
       if constexpr (_i < size_) {
         if (i_ == _i) {
-          using CurrentType =
-              std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
+          using CurrentType = std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
 
           auto res = Parser<R, W, CurrentType, ProcessorsType>::read(*r_, _var);
 
@@ -101,19 +93,14 @@ namespace rfl::parsing {
             move_to(&(std::get<_i>(*tuple_)), &(*res));
             ++i_;
           } else {
-            *_err = Error(
-                "Failed to parse field " + std::to_string(_i) + ": " +
-                res.error()->what()
-            );
+            *_err =
+              Error("Failed to parse field " + std::to_string(_i) + ": " + res.error()->what());
           }
           return;
         }
         read_impl<_i + 1>(_var, _err);
       } else {
-        *_err = Error(
-            "Expected " + std::to_string(size_) +
-            " fields, but got at least one more."
-        );
+        *_err = Error("Expected " + std::to_string(size_) + " fields, but got at least one more.");
         return;
       }
     }
@@ -133,17 +120,12 @@ namespace rfl::parsing {
     void move_to(Target* _t, Source* _s) const {
       if constexpr (std::is_const_v<Target>) {
         return move_to(const_cast<std::remove_const_t<Target>*>(_t), _s);
-      } else if constexpr (!internal::is_array_v<Source> &&
-                           !std::is_array_v<Target>) {
+      } else if constexpr (!internal::is_array_v<Source> && !std::is_array_v<Target>) {
         ::new (_t) Target(std::move(*_s));
       } else if constexpr (internal::is_array_v<Source>) {
-        for (size_t i = 0; i < _s->arr_.size(); ++i) {
-          move_to(&((*_t)[i]), &(_s->arr_[i]));
-        }
+        for (size_t i = 0; i < _s->arr_.size(); ++i) { move_to(&((*_t)[i]), &(_s->arr_[i])); }
       } else {
-        for (size_t i = 0; i < _s->size(); ++i) {
-          move_to(&((*_t)[i]), &((*_s)[i]));
-        }
+        for (size_t i = 0; i < _s->size(); ++i) { move_to(&((*_t)[i]), &((*_s)[i])); }
       }
     }
 
diff --git a/include/rfl/parsing/VectorParser.hpp b/include/rfl/parsing/VectorParser.hpp
index a368660..f2e28ad 100644
--- a/include/rfl/parsing/VectorParser.hpp
+++ b/include/rfl/parsing/VectorParser.hpp
@@ -40,8 +40,7 @@ namespace rfl {
 
       using T = typename VecType::value_type;
 
-      static Result<VecType>
-      read(const R& _r, const InputVarType& _var) noexcept {
+      static Result<VecType> read(const R& _r, const InputVarType& _var) noexcept {
         if constexpr (treat_as_map()) {
           return MapParser<R, W, VecType, ProcessorsType>::read(_r, _var);
         } else if constexpr (is_forward_list<VecType>()) {
@@ -52,15 +51,14 @@ namespace rfl {
             }
             return list;
           };
-          return Parser<R, W, std::vector<T>, ProcessorsType>::read(_r, _var)
-              .transform(to_forward_list);
+          return Parser<R, W, std::vector<T>, ProcessorsType>::read(_r, _var).transform(
+            to_forward_list
+          );
         } else {
-          const auto parse = [&](const InputArrayType& _arr
-                             ) -> Result<VecType> {
-            VecType vec;
-            auto    vector_reader =
-                VectorReader<R, W, VecType, ProcessorsType>(&_r, &vec);
-            const auto err = _r.read_array(vector_reader, _arr);
+          const auto parse = [&](const InputArrayType& _arr) -> Result<VecType> {
+            VecType    vec;
+            auto       vector_reader = VectorReader<R, W, VecType, ProcessorsType>(&_r, &vec);
+            const auto err           = _r.read_array(vector_reader, _arr);
             if (err) {
               return *err;
             }
@@ -71,51 +69,38 @@ namespace rfl {
       }
 
       template <class P>
-      static void
-      write(const W& _w, const VecType& _vec, const P& _parent) noexcept {
+      static void write(const W& _w, const VecType& _vec, const P& _parent) noexcept {
         if constexpr (treat_as_map()) {
           MapParser<R, W, VecType, ProcessorsType>::write(_w, _vec, _parent);
         } else {
-          auto arr = ParentType::add_array(
-              _w, std::distance(_vec.begin(), _vec.end()), _parent
-          );
-          const auto new_parent = typename ParentType::Array {&arr};
+          auto arr = ParentType::add_array(_w, std::distance(_vec.begin(), _vec.end()), _parent);
+          const auto new_parent = typename ParentType::Array { &arr };
           for (const auto& v : _vec) {
-            Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
-                _w, v, new_parent
-            );
+            Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, v, new_parent);
           }
           _w.end_array(&arr);
         }
       }
 
       /// Generates a schema for the underlying type.
-      static schema::Type to_schema(
-          std::map<std::string, schema::Type>* _definitions
-      ) {
+      static schema::Type to_schema(std::map<std::string, schema::Type>* _definitions) {
         using Type = schema::Type;
-        return Type {Type::TypedArray {
-            .type_ = Ref<Type>::make(
-                Parser<R, W, T, ProcessorsType>::to_schema(_definitions)
-            )
-        }};
+        return Type { Type::TypedArray {
+          .type_ = Ref<Type>::make(Parser<R, W, T, ProcessorsType>::to_schema(_definitions)) } };
       }
 
      private:
       static constexpr bool treat_as_map() {
         if constexpr (is_map_like_not_multimap<VecType>()) {
-          if constexpr (internal::has_reflection_type_v<
-                            typename T::first_type>) {
-            using U =
-                std::remove_cvref_t<typename T::first_type::ReflectionType>;
+          if constexpr (internal::has_reflection_type_v<typename T::first_type>) {
+            using U = std::remove_cvref_t<typename T::first_type::ReflectionType>;
             return std::is_same<U, std::string>() || std::is_integral_v<U> ||
                    std::is_floating_point_v<U>;
 
             // We do not need std::string here, it is already caught by the
             // template specialization.
           } else if constexpr (std::is_integral_v<typename T::first_type> ||
-                               std::is_floating_point_v<
-                                   typename T::first_type>) {
+                               std::is_floating_point_v<typename T::first_type>) {
             return true;
           } else {
             return false;
diff --git a/include/rfl/parsing/VectorReader.hpp b/include/rfl/parsing/VectorReader.hpp
index 9df7278..48a6af5 100644
--- a/include/rfl/parsing/VectorReader.hpp
+++ b/include/rfl/parsing/VectorReader.hpp
@@ -25,9 +25,7 @@ namespace rfl::parsing {
         if constexpr (is_map_like_v<VecType>) {
           return get_pair(_var);
         } else {
-          return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
-              *r_, _var
-          );
+          return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(*r_, _var);
         }
       };
 
@@ -47,11 +45,7 @@ namespace rfl::parsing {
     auto get_pair(const auto& _var) const {
       using K = std::remove_cvref_t<typename T::first_type>;
       using V = std::remove_cvref_t<typename T::second_type>;
-      return Parser<
-          R,
-          W,
-          std::remove_cvref_t<std::pair<K, V>>,
-          ProcessorsType>::read(*r_, _var);
+      return Parser<R, W, std::remove_cvref_t<std::pair<K, V>>, ProcessorsType>::read(*r_, _var);
     }
 
    private:
diff --git a/include/rfl/parsing/ViewReader.hpp b/include/rfl/parsing/ViewReader.hpp
index a7402b5..e9f4fa9 100644
--- a/include/rfl/parsing/ViewReader.hpp
+++ b/include/rfl/parsing/ViewReader.hpp
@@ -20,13 +20,13 @@ namespace rfl::parsing {
 
    public:
     ViewReader(
-        const R*                 _r,
-        ViewType*                _view,
-        std::array<bool, size_>* _found,
-        std::array<bool, size_>* _set,
-        std::vector<Error>*      _errors
+      const R*                 _r,
+      ViewType*                _view,
+      std::array<bool, size_>* _found,
+      std::array<bool, size_>* _set,
+      std::vector<Error>*      _errors
     )
-        : r_(_r), view_(_view), found_(_found), set_(_set), errors_(_errors) {}
+      : r_(_r), view_(_view), found_(_found), set_(_set), errors_(_errors) {}
 
     ~ViewReader() = default;
 
@@ -34,14 +34,7 @@ namespace rfl::parsing {
     /// such a field exists in the underlying view.
     void read(const std::string_view& _name, const InputVarType& _var) const {
       assign_to_matching_field(
-          *r_,
-          _name,
-          _var,
-          view_,
-          errors_,
-          found_,
-          set_,
-          std::make_integer_sequence<int, size_>()
+        *r_, _name, _var, view_, errors_, found_, set_, std::make_integer_sequence<int, size_>()
       );
     }
 
@@ -56,29 +49,26 @@ namespace rfl::parsing {
    private:
     template <int i>
     static void assign_if_field_matches(
-        const R&                _r,
-        const std::string_view& _current_name,
-        const auto&             _var,
-        auto*                   _view,
-        auto*                   _errors,
-        auto*                   _found,
-        auto*                   _set,
-        bool*                   _already_assigned
+      const R&                _r,
+      const std::string_view& _current_name,
+      const auto&             _var,
+      auto*                   _view,
+      auto*                   _errors,
+      auto*                   _found,
+      auto*                   _set,
+      bool*                   _already_assigned
     ) {
-      using FieldType    = std::tuple_element_t<i, typename ViewType::Fields>;
-      using OriginalType = typename FieldType::Type;
-      using T =
-          std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
+      using FieldType     = std::tuple_element_t<i, typename ViewType::Fields>;
+      using OriginalType  = typename FieldType::Type;
+      using T             = std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
       constexpr auto name = FieldType::name();
-      if (!(*_already_assigned) && !std::get<i>(*_found) &&
-          _current_name == name) {
+      if (!(*_already_assigned) && !std::get<i>(*_found) && _current_name == name) {
         std::get<i>(*_found) = true;
         *_already_assigned   = true;
         auto res             = Parser<R, W, T, ProcessorsType>::read(_r, _var);
         if (!res) {
           _errors->emplace_back(Error(
-              "Failed to parse field '" + std::string(name) +
-              "': " + std::move(res.error()->what())
+            "Failed to parse field '" + std::string(name) + "': " + std::move(res.error()->what())
           ));
           return;
         }
@@ -96,14 +86,7 @@ namespace rfl::parsing {
     assign_to_matching_field(const R& _r, const std::string_view& _current_name, const auto& _var, auto* _view, auto* _errors, auto* _found, auto* _set, std::integer_sequence<int, is...>) {
       bool already_assigned = false;
       (assign_if_field_matches<is>(
-           _r,
-           _current_name,
-           _var,
-           _view,
-           _errors,
-           _found,
-           _set,
-           &already_assigned
+         _r, _current_name, _var, _view, _errors, _found, _set, &already_assigned
        ),
        ...);
     }
@@ -123,10 +106,8 @@ namespace rfl::parsing {
     void call_destructor_on_one_if_necessary() const {
       using FieldType    = std::tuple_element_t<_i, typename ViewType::Fields>;
       using OriginalType = std::remove_cvref_t<typename FieldType::Type>;
-      using ValueType =
-          std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
-      if constexpr (!std::is_array_v<ValueType> &&
-                    std::is_pointer_v<OriginalType> &&
+      using ValueType    = std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
+      if constexpr (!std::is_array_v<ValueType> && std::is_pointer_v<OriginalType> &&
                     std::is_destructible_v<ValueType>) {
         if (std::get<_i>(*set_)) {
           rfl::get<_i>(*view_)->~ValueType();
@@ -143,20 +124,13 @@ namespace rfl::parsing {
     static void move_to(Target* _t, Source* _s) {
       if constexpr (std::is_const_v<Target>) {
         return move_to(const_cast<std::remove_const_t<Target>*>(_t), _s);
-      } else if constexpr (!rfl::internal::is_array_v<Source> &&
-                           !std::is_array_v<Target>) {
+      } else if constexpr (!rfl::internal::is_array_v<Source> && !std::is_array_v<Target>) {
         ::new (_t) Target(std::move(*_s));
       } else if constexpr (rfl::internal::is_array_v<Source>) {
-        static_assert(
-            std::is_array_v<Target>, "Expected target to be a c-array."
-        );
-        for (size_t i = 0; i < _s->arr_.size(); ++i) {
-          move_to(&((*_t)[i]), &(_s->arr_[i]));
-        }
+        static_assert(std::is_array_v<Target>, "Expected target to be a c-array.");
+        for (size_t i = 0; i < _s->arr_.size(); ++i) { move_to(&((*_t)[i]), &(_s->arr_[i])); }
       } else {
-        for (size_t i = 0; i < _s->size(); ++i) {
-          move_to(&((*_t)[i]), &((*_s)[i]));
-        }
+        for (size_t i = 0; i < _s->size(); ++i) { move_to(&((*_t)[i]), &((*_s)[i])); }
       }
     }
 
diff --git a/include/rfl/parsing/is_map_like.hpp b/include/rfl/parsing/is_map_like.hpp
index 23259cd..bfa038e 100644
--- a/include/rfl/parsing/is_map_like.hpp
+++ b/include/rfl/parsing/is_map_like.hpp
@@ -28,7 +28,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_map_like_v =
-        is_map_like<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_map_like<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/is_map_like_not_multimap.hpp b/include/rfl/parsing/is_map_like_not_multimap.hpp
index 4d5751c..e0227e0 100644
--- a/include/rfl/parsing/is_map_like_not_multimap.hpp
+++ b/include/rfl/parsing/is_map_like_not_multimap.hpp
@@ -18,8 +18,7 @@ namespace rfl {
     class is_map_like_not_multimap<std::map<K, V>> : public std::true_type {};
 
     template <class K, class V>
-    class is_map_like_not_multimap<std::unordered_map<K, V>>
-        : public std::true_type {};
+    class is_map_like_not_multimap<std::unordered_map<K, V>> : public std::true_type {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/is_required.hpp b/include/rfl/parsing/is_required.hpp
index 835f9a6..9417844 100644
--- a/include/rfl/parsing/is_required.hpp
+++ b/include/rfl/parsing/is_required.hpp
@@ -38,16 +38,13 @@ namespace rfl {
     consteval bool is_required() {
       using Type = std::remove_cvref_t<std::remove_pointer_t<T>>;
       if constexpr (internal::has_reflection_type_v<Type>) {
-        return is_required<
-            typename Type::ReflectionType,
-            _ignore_empty_containers>();
+        return is_required<typename Type::ReflectionType, _ignore_empty_containers>();
       } else if constexpr (internal::is_rename_v<Type>) {
         return is_required<typename Type::Type, _ignore_empty_containers>();
       } else {
         return !(
-            is_never_required_v<Type> ||
-            (_ignore_empty_containers &&
-             (is_vector_like_v<Type> || is_map_like_v<Type>))
+          is_never_required_v<Type> ||
+          (_ignore_empty_containers && (is_vector_like_v<Type> || is_map_like_v<Type>))
         );
       }
     }
diff --git a/include/rfl/parsing/is_set_like.hpp b/include/rfl/parsing/is_set_like.hpp
index 46cec3f..3f14501 100644
--- a/include/rfl/parsing/is_set_like.hpp
+++ b/include/rfl/parsing/is_set_like.hpp
@@ -28,7 +28,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_set_like_v =
-        is_set_like<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_set_like<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace parsing
 
diff --git a/include/rfl/parsing/is_tagged_union_wrapper.hpp b/include/rfl/parsing/is_tagged_union_wrapper.hpp
index 46b688a..17e562f 100644
--- a/include/rfl/parsing/is_tagged_union_wrapper.hpp
+++ b/include/rfl/parsing/is_tagged_union_wrapper.hpp
@@ -16,18 +16,15 @@ namespace rfl {
     class is_tagged_union_wrapper : public std::false_type {};
 
     template <class T, class TagType, internal::StringLiteral _discriminator>
-    class is_tagged_union_wrapper<
-        TaggedUnionWrapperNoFields<T, TagType, _discriminator>>
-        : public std::true_type {};
+    class is_tagged_union_wrapper<TaggedUnionWrapperNoFields<T, TagType, _discriminator>>
+      : public std::true_type {};
 
     template <class T, class TagType, internal::StringLiteral _discriminator>
-    class is_tagged_union_wrapper<
-        TaggedUnionWrapperWithFields<T, TagType, _discriminator>>
-        : public std::true_type {};
+    class is_tagged_union_wrapper<TaggedUnionWrapperWithFields<T, TagType, _discriminator>>
+      : public std::true_type {};
 
     template <class T>
-    constexpr bool is_tagged_union_wrapper_v =
-        is_tagged_union_wrapper<T>::value;
+    constexpr bool is_tagged_union_wrapper_v = is_tagged_union_wrapper<T>::value;
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/is_vector_like.hpp b/include/rfl/parsing/is_vector_like.hpp
index 39a3372..4b57360 100644
--- a/include/rfl/parsing/is_vector_like.hpp
+++ b/include/rfl/parsing/is_vector_like.hpp
@@ -45,7 +45,7 @@ namespace rfl {
 
     template <class T>
     constexpr bool is_vector_like_v =
-        is_vector_like<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+      is_vector_like<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/is_view_reader.hpp b/include/rfl/parsing/is_view_reader.hpp
index 9bf872b..afe1699 100644
--- a/include/rfl/parsing/is_view_reader.hpp
+++ b/include/rfl/parsing/is_view_reader.hpp
@@ -12,12 +12,11 @@ namespace rfl ::parsing {
   class is_view_reader : public std::false_type {};
 
   template <class R, class W, class NamedTupleType, class ProcessorsType>
-  class is_view_reader<ViewReader<R, W, NamedTupleType, ProcessorsType>>
-      : public std::true_type {};
+  class is_view_reader<ViewReader<R, W, NamedTupleType, ProcessorsType>> : public std::true_type {};
 
   template <class T>
   constexpr bool is_view_reader_v =
-      is_view_reader<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+    is_view_reader<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
 
 } // namespace rfl::parsing
 
diff --git a/include/rfl/parsing/schema/Type.hpp b/include/rfl/parsing/schema/Type.hpp
index 176d3de..97160d4 100644
--- a/include/rfl/parsing/schema/Type.hpp
+++ b/include/rfl/parsing/schema/Type.hpp
@@ -84,26 +84,26 @@ namespace rfl::parsing::schema {
     };
 
     using VariantType = std::variant<
-        Boolean,
-        Int32,
-        Int64,
-        UInt32,
-        UInt64,
-        Integer,
-        Float,
-        Double,
-        String,
-        AnyOf,
-        Description,
-        FixedSizeTypedArray,
-        Literal,
-        Object,
-        Optional,
-        Reference,
-        StringMap,
-        Tuple,
-        TypedArray,
-        Validated>;
+      Boolean,
+      Int32,
+      Int64,
+      UInt32,
+      UInt64,
+      Integer,
+      Float,
+      Double,
+      String,
+      AnyOf,
+      Description,
+      FixedSizeTypedArray,
+      Literal,
+      Object,
+      Optional,
+      Reference,
+      StringMap,
+      Tuple,
+      TypedArray,
+      Validated>;
 
     /// A type can be determined to be any of the above.
     VariantType variant_;
diff --git a/include/rfl/parsing/schema/ValidationType.hpp b/include/rfl/parsing/schema/ValidationType.hpp
index d59780f..73737ad 100644
--- a/include/rfl/parsing/schema/ValidationType.hpp
+++ b/include/rfl/parsing/schema/ValidationType.hpp
@@ -57,17 +57,17 @@ namespace rfl::parsing::schema {
     };
 
     using VariantType = std::variant<
-        AllOf,
-        AnyOf,
-        EqualTo,
-        ExclusiveMaximum,
-        ExclusiveMinimum,
-        Maximum,
-        Minimum,
-        OneOf,
-        NotEqualTo,
-        Regex,
-        Size>;
+      AllOf,
+      AnyOf,
+      EqualTo,
+      ExclusiveMaximum,
+      ExclusiveMinimum,
+      Maximum,
+      Minimum,
+      OneOf,
+      NotEqualTo,
+      Regex,
+      Size>;
 
     /// A type can be determined to be any of the above.
     VariantType variant_;
diff --git a/include/rfl/parsing/schema/make.hpp b/include/rfl/parsing/schema/make.hpp
index 2e94623..77f95b6 100644
--- a/include/rfl/parsing/schema/make.hpp
+++ b/include/rfl/parsing/schema/make.hpp
@@ -12,8 +12,8 @@ namespace rfl::parsing::schema {
   template <class R, class W, class T, class ProcessorsType>
   Definition make() {
     std::map<std::string, Type> definitions;
-    auto root = Parser<R, W, T, ProcessorsType>::to_schema(&definitions);
-    return Definition {.root_ = root, .definitions_ = definitions};
+    auto                        root = Parser<R, W, T, ProcessorsType>::to_schema(&definitions);
+    return Definition { .root_ = root, .definitions_ = definitions };
   }
 
 } // namespace rfl::parsing::schema
diff --git a/include/rfl/parsing/supports_attributes.hpp b/include/rfl/parsing/supports_attributes.hpp
index b37bf93..d11c31b 100644
--- a/include/rfl/parsing/supports_attributes.hpp
+++ b/include/rfl/parsing/supports_attributes.hpp
@@ -12,20 +12,16 @@ namespace rfl {
 
     /// Determines whether a writer supports attributes.
     template <class W>
-    concept supports_attributes = requires(
-        W                            w,
-        std::string_view             name,
-        typename W::OutputObjectType obj,
-        bool                         is_attribute
-    ) {
-      {
-        w.add_value_to_object(name, name, &obj, is_attribute)
-      } -> std::same_as<typename W::OutputVarType>;
+    concept supports_attributes =
+      requires(W w, std::string_view name, typename W::OutputObjectType obj, bool is_attribute) {
+        {
+          w.add_value_to_object(name, name, &obj, is_attribute)
+        } -> std::same_as<typename W::OutputVarType>;
 
-      {
-        w.add_null_to_object(name, &obj, is_attribute)
-      } -> std::same_as<typename W::OutputVarType>;
-    };
+        {
+          w.add_null_to_object(name, &obj, is_attribute)
+        } -> std::same_as<typename W::OutputVarType>;
+      };
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/parsing/to_single_error_message.hpp b/include/rfl/parsing/to_single_error_message.hpp
index 63be7e3..b7ec7ab 100644
--- a/include/rfl/parsing/to_single_error_message.hpp
+++ b/include/rfl/parsing/to_single_error_message.hpp
@@ -11,21 +11,18 @@ namespace rfl::parsing {
 
   /// Combines a set of errors to a single, readable error message.
   inline Error to_single_error_message(
-      std::vector<Error>         _errors,
-      std::optional<std::string> _msg_prefix = std::nullopt,
-      size_t                     _err_limit  = 10
+    std::vector<Error>         _errors,
+    std::optional<std::string> _msg_prefix = std::nullopt,
+    size_t                     _err_limit  = 10
   ) {
     if (_errors.size() == 1) {
       return std::move(_errors[0]);
     } else {
       std::string msg =
-          _msg_prefix ? *_msg_prefix
-                      : "Found " + std::to_string(_errors.size()) + " errors:";
+        _msg_prefix ? *_msg_prefix : "Found " + std::to_string(_errors.size()) + " errors:";
       for (size_t i = 0; i < _errors.size() && i < _err_limit; ++i) {
         msg += "\n" + std::to_string(i + 1) + ") " +
-               internal::strings::replace_all(
-                   _errors.at(i).what(), "\n", "\n    "
-               );
+               internal::strings::replace_all(_errors.at(i).what(), "\n", "\n    ");
       }
       if (_errors.size() > _err_limit) {
         msg += "\n...\nMore than " + std::to_string(_err_limit) +
diff --git a/include/rfl/patterns.hpp b/include/rfl/patterns.hpp
index 5d3733f..44a0ace 100644
--- a/include/rfl/patterns.hpp
+++ b/include/rfl/patterns.hpp
@@ -11,28 +11,26 @@ namespace rfl {
 
   /// This pattern will match valid Base64 encoded strings with or without
   /// padding.
-  using Base64Encoded =
-      Pattern<R"(^[A-Za-z0-9+/]*(={0,2})?$)", "Base64Encoded">;
+  using Base64Encoded = Pattern<R"(^[A-Za-z0-9+/]*(={0,2})?$)", "Base64Encoded">;
 
   /// This pattern will match email addresses.
-  using Email =
-      Pattern<R"(^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$)", "Email">;
+  using Email = Pattern<R"(^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$)", "Email">;
 
   using UUIDv1 = Pattern<
-      R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-1[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
-      "UUIDv1">;
+    R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-1[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
+    "UUIDv1">;
 
   using UUIDv2 = Pattern<
-      R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-2[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
-      "UUIDv2">;
+    R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-2[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
+    "UUIDv2">;
 
   using UUIDv3 = Pattern<
-      R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-3[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
-      "UUIDv3">;
+    R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-3[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
+    "UUIDv3">;
 
   using UUIDv4 = Pattern<
-      R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
-      "UUIDv4">;
+    R"(^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$)",
+    "UUIDv4">;
 
 } // namespace rfl
 
diff --git a/include/rfl/remove_fields.hpp b/include/rfl/remove_fields.hpp
index a1d276d..7395f8c 100644
--- a/include/rfl/remove_fields.hpp
+++ b/include/rfl/remove_fields.hpp
@@ -13,8 +13,8 @@ namespace rfl {
   /// Recursively removes all of the fields signified by _names from the
   /// NamedTupleType.
   template <class NamedTupleType, internal::StringLiteral... _names>
-  using remove_fields_t = typename internal::
-      remove_fields<std::remove_cvref_t<NamedTupleType>, _names...>::type;
+  using remove_fields_t =
+    typename internal::remove_fields<std::remove_cvref_t<NamedTupleType>, _names...>::type;
 
 } // namespace rfl
 
diff --git a/include/rfl/replace.hpp b/include/rfl/replace.hpp
index faedc62..4acf0b4 100644
--- a/include/rfl/replace.hpp
+++ b/include/rfl/replace.hpp
@@ -13,17 +13,15 @@ namespace rfl {
   auto replace(T&& _t, RField&& _field, OtherRFields&&... _other_fields) {
     if constexpr (internal::is_named_tuple_v<T>) {
       return std::forward<T>(_t).replace(
-          to_named_tuple(std::forward<RField>(_field)),
-          to_named_tuple(std::forward<OtherRFields>(_other_fields))...
+        to_named_tuple(std::forward<RField>(_field)),
+        to_named_tuple(std::forward<OtherRFields>(_other_fields))...
       );
     } else {
-      return from_named_tuple<T>(
-          to_named_tuple(std::forward<T>(_t))
-              .replace(
-                  to_named_tuple(std::forward<RField>(_field)),
-                  to_named_tuple(std::forward<OtherRFields>(_other_fields))...
-              )
-      );
+      return from_named_tuple<T>(to_named_tuple(std::forward<T>(_t))
+                                   .replace(
+                                     to_named_tuple(std::forward<RField>(_field)),
+                                     to_named_tuple(std::forward<OtherRFields>(_other_fields))...
+                                   ));
     }
   }
 
@@ -33,13 +31,13 @@ namespace rfl {
   auto replace(const T& _t, RField&& _field, OtherRFields&&... _other_fields) {
     if constexpr (internal::is_named_tuple_v<T>) {
       return _t.replace(
-          to_named_tuple(std::forward<RField>(_field)),
-          to_named_tuple(std::forward<OtherRFields>(_other_fields))...
+        to_named_tuple(std::forward<RField>(_field)),
+        to_named_tuple(std::forward<OtherRFields>(_other_fields))...
       );
     } else {
       return from_named_tuple<T>(to_named_tuple(_t).replace(
-          to_named_tuple(std::forward<RField>(_field)),
-          to_named_tuple(std::forward<OtherRFields>(_other_fields))...
+        to_named_tuple(std::forward<RField>(_field)),
+        to_named_tuple(std::forward<OtherRFields>(_other_fields))...
       ));
     }
   }
diff --git a/include/rfl/toml/Reader.hpp b/include/rfl/toml/Reader.hpp
index b4b4739..df11539 100644
--- a/include/rfl/toml/Reader.hpp
+++ b/include/rfl/toml/Reader.hpp
@@ -26,12 +26,10 @@ namespace rfl::toml {
 
     template <class T>
     static constexpr bool has_custom_constructor =
-        (requires(InputVarType var) { T::from_toml_obj(var); });
+      (requires(InputVarType var) { T::from_toml_obj(var); });
 
-    rfl::Result<InputVarType> get_field(
-        const std::string&     _name,
-        const InputObjectType& _obj
-    ) const noexcept {
+    rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType& _obj)
+      const noexcept {
       auto var = (*_obj)[_name];
       if (!var) {
         return rfl::Error("Object contains no field named '" + _name + "'.");
@@ -39,9 +37,7 @@ namespace rfl::toml {
       return var.node();
     }
 
-    bool is_empty(const InputVarType& _var) const noexcept {
-      return !_var && true;
-    }
+    bool is_empty(const InputVarType& _var) const noexcept { return !_var && true; }
 
     template <class T>
     rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
@@ -74,8 +70,7 @@ namespace rfl::toml {
       }
     }
 
-    rfl::Result<InputArrayType> to_array(const InputVarType& _var
-    ) const noexcept {
+    rfl::Result<InputArrayType> to_array(const InputVarType& _var) const noexcept {
       const auto ptr = _var->as_array();
       if (!ptr) {
         return rfl::Error("Could not cast to an array!");
@@ -84,10 +79,8 @@ namespace rfl::toml {
     }
 
     template <class ArrayReader>
-    std::optional<Error> read_array(
-        const ArrayReader&    _array_reader,
-        const InputArrayType& _arr
-    ) const noexcept {
+    std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+      const noexcept {
       for (auto& node : *_arr) {
         const auto err = _array_reader.read(&node);
         if (err) {
@@ -98,18 +91,13 @@ namespace rfl::toml {
     }
 
     template <class ObjectReader>
-    std::optional<Error> read_object(
-        const ObjectReader& _object_reader,
-        InputObjectType     _obj
-    ) const noexcept {
-      for (auto& [k, v] : *_obj) {
-        _object_reader.read(std::string_view(k), &v);
-      }
+    std::optional<Error> read_object(const ObjectReader& _object_reader, InputObjectType _obj)
+      const noexcept {
+      for (auto& [k, v] : *_obj) { _object_reader.read(std::string_view(k), &v); }
       return std::nullopt;
     }
 
-    rfl::Result<InputObjectType> to_object(const InputVarType& _var
-    ) const noexcept {
+    rfl::Result<InputObjectType> to_object(const InputVarType& _var) const noexcept {
       const auto ptr = _var->as_table();
       if (!ptr) {
         return rfl::Error("Could not cast to a table!");
@@ -118,8 +106,7 @@ namespace rfl::toml {
     }
 
     template <class T>
-    rfl::Result<T> use_custom_constructor(const InputVarType _var
-    ) const noexcept {
+    rfl::Result<T> use_custom_constructor(const InputVarType _var) const noexcept {
       try {
         return T::from_toml_obj(_var);
       } catch (std::exception& e) { return rfl::Error(e.what()); }
diff --git a/include/rfl/toml/Writer.hpp b/include/rfl/toml/Writer.hpp
index 42e6229..219bf6a 100644
--- a/include/rfl/toml/Writer.hpp
+++ b/include/rfl/toml/Writer.hpp
@@ -39,74 +39,65 @@ namespace rfl::toml {
 
     template <class T>
     OutputArrayType array_as_root(const T _size) const noexcept {
-      static_assert(
-          rfl::always_false_v<T>, "TOML only allows tables as the root element."
-      );
-      return OutputArrayType {nullptr};
+      static_assert(rfl::always_false_v<T>, "TOML only allows tables as the root element.");
+      return OutputArrayType { nullptr };
     }
 
     OutputObjectType object_as_root(const size_t _size) const noexcept {
-      return OutputObjectType {root_};
+      return OutputObjectType { root_ };
     }
 
     OutputVarType null_as_root() const noexcept { return OutputVarType {}; }
 
     template <class T>
     OutputVarType value_as_root(const T& _var) const noexcept {
-      static_assert(
-          rfl::always_false_v<T>, "TOML only allows tables as the root element."
-      );
+      static_assert(rfl::always_false_v<T>, "TOML only allows tables as the root element.");
       return OutputVarType {};
     }
 
-    OutputArrayType add_array_to_array(
-        const size_t     _size,
-        OutputArrayType* _parent
-    ) const noexcept {
+    OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+      const noexcept {
       const auto i = _parent->val_->size();
       _parent->val_->push_back(::toml::array());
-      return OutputArrayType {_parent->val_->at(i).as_array()};
+      return OutputArrayType { _parent->val_->at(i).as_array() };
     }
 
     OutputArrayType add_array_to_object(
-        const std::string_view& _name,
-        const size_t            _size,
-        OutputObjectType*       _parent
+      const std::string_view& _name,
+      const size_t            _size,
+      OutputObjectType*       _parent
     ) const noexcept {
       _parent->val_->emplace(_name, ::toml::array());
-      return OutputArrayType {_parent->val_->at_path(_name).as_array()};
+      return OutputArrayType { _parent->val_->at_path(_name).as_array() };
     }
 
-    OutputObjectType add_object_to_array(
-        const size_t     _size,
-        OutputArrayType* _parent
-    ) const noexcept {
+    OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+      const noexcept {
       const auto i = _parent->val_->size();
       _parent->val_->push_back(::toml::table());
-      return OutputObjectType {_parent->val_->at(i).as_table()};
+      return OutputObjectType { _parent->val_->at(i).as_table() };
     }
 
     OutputObjectType add_object_to_object(
-        const std::string_view& _name,
-        const size_t            _size,
-        OutputObjectType*       _parent
+      const std::string_view& _name,
+      const size_t            _size,
+      OutputObjectType*       _parent
     ) const noexcept {
       _parent->val_->emplace(_name, ::toml::table());
-      return OutputObjectType {_parent->val_->at_path(_name).as_table()};
+      return OutputObjectType { _parent->val_->at_path(_name).as_table() };
     }
 
     template <class T>
-    OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-        const noexcept {
+    OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
       _parent->val_->push_back(::toml::value(_var));
       return OutputVarType {};
     }
 
     template <class T>
     OutputVarType add_value_to_object(
-        const std::string_view& _name,
-        const T&                _var,
-        OutputObjectType*       _parent
+      const std::string_view& _name,
+      const T&                _var,
+      OutputObjectType*       _parent
     ) const noexcept {
       _parent->val_->emplace(_name, ::toml::value(_var));
       return OutputVarType {};
@@ -117,10 +108,8 @@ namespace rfl::toml {
       return OutputVarType {};
     }
 
-    OutputVarType add_null_to_object(
-        const std::string_view& _name,
-        OutputObjectType*       _parent
-    ) const noexcept {
+    OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+      const noexcept {
       _parent->val_->emplace(_name, ::toml::value(std::string("")));
       return OutputVarType {};
     }
diff --git a/include/rfl/toml/load.hpp b/include/rfl/toml/load.hpp
index 64fdf8b..0d9a729 100644
--- a/include/rfl/toml/load.hpp
+++ b/include/rfl/toml/load.hpp
@@ -9,9 +9,7 @@ namespace rfl::toml {
 
   template <class T, class... Ps>
   Result<T> load(const std::string& _fname) {
-    const auto read_string = [](const auto& _str) {
-      return read<T, Ps...>(_str);
-    };
+    const auto read_string = [](const auto& _str) { return read<T, Ps...>(_str); };
     return rfl::io::load_string(_fname).and_then(read_string);
   }
 
diff --git a/include/rfl/toml/read.hpp b/include/rfl/toml/read.hpp
index 04e858d..fb85982 100644
--- a/include/rfl/toml/read.hpp
+++ b/include/rfl/toml/read.hpp
@@ -31,10 +31,8 @@ namespace rfl::toml {
   /// Parses an object from a stringstream.
   template <class T, class... Ps>
   auto read(std::istream& _stream) {
-    const auto toml_str = std::string(
-        std::istreambuf_iterator<char>(_stream),
-        std::istreambuf_iterator<char>()
-    );
+    const auto toml_str =
+      std::string(std::istreambuf_iterator<char>(_stream), std::istreambuf_iterator<char>());
     return read<T, Ps...>(toml_str);
   }
 
diff --git a/include/rfl/visit.hpp b/include/rfl/visit.hpp
index e2af75c..edcbbb0 100644
--- a/include/rfl/visit.hpp
+++ b/include/rfl/visit.hpp
@@ -13,28 +13,18 @@ namespace rfl {
 
   /// Implements the visitor pattern for Literals.
   template <class Visitor, internal::StringLiteral... _fields, class... Args>
-  inline auto visit(
-      const Visitor&            _visitor,
-      const Literal<_fields...> _literal,
-      const Args&... _args
-  ) {
+  inline auto
+  visit(const Visitor& _visitor, const Literal<_fields...> _literal, const Args&... _args) {
     constexpr int size = sizeof...(_fields);
     using WrapperType  = internal::VisitorWrapper<Visitor, _fields...>;
     const auto wrapper = WrapperType(&_visitor);
-    return internal::VisitTree::visit<0, size, WrapperType>(
-        wrapper, _literal.value(), _args...
-    );
+    return internal::VisitTree::visit<0, size, WrapperType>(wrapper, _literal.value(), _args...);
   }
 
   /// Implements the visitor pattern for TaggedUnions.
-  template <
-      class Visitor,
-      internal::StringLiteral _discriminator,
-      class... Args>
-  inline auto visit(
-      const Visitor&                              _visitor,
-      const TaggedUnion<_discriminator, Args...>& _tagged_union
-  ) {
+  template <class Visitor, internal::StringLiteral _discriminator, class... Args>
+  inline auto
+  visit(const Visitor& _visitor, const TaggedUnion<_discriminator, Args...>& _tagged_union) {
     return std::visit(_visitor, _tagged_union.variant());
   }
 
diff --git a/include/rfl/xml/Parser.hpp b/include/rfl/xml/Parser.hpp
index 186a139..2223a0e 100644
--- a/include/rfl/xml/Parser.hpp
+++ b/include/rfl/xml/Parser.hpp
@@ -17,22 +17,15 @@ namespace rfl {
     /// to a template specialization for the NamedTuple parser to accommodate
     /// for it.
     template <class ProcessorsType, class... FieldTypes>
-      requires AreReaderAndWriter<
+      requires AreReaderAndWriter<xml::Reader, xml::Writer, NamedTuple<FieldTypes...>>
+    struct Parser<xml::Reader, xml::Writer, NamedTuple<FieldTypes...>, ProcessorsType>
+      : public NamedTupleParser<
           xml::Reader,
           xml::Writer,
-          NamedTuple<FieldTypes...>>
-    struct Parser<
-        xml::Reader,
-        xml::Writer,
-        NamedTuple<FieldTypes...>,
-        ProcessorsType>
-        : public NamedTupleParser<
-              xml::Reader,
-              xml::Writer,
-              /*_ignore_empty_containers=*/true,
-              /*_all_required=*/ProcessorsType::all_required_,
-              ProcessorsType,
-              FieldTypes...> {};
+          /*_ignore_empty_containers=*/true,
+          /*_all_required=*/ProcessorsType::all_required_,
+          ProcessorsType,
+          FieldTypes...> {};
 
   } // namespace parsing
 } // namespace rfl
diff --git a/include/rfl/xml/Reader.hpp b/include/rfl/xml/Reader.hpp
index 2bef7ba..124a572 100644
--- a/include/rfl/xml/Reader.hpp
+++ b/include/rfl/xml/Reader.hpp
@@ -52,26 +52,21 @@ namespace rfl {
       /// XML-only helper function. This is needed because XML distinguishes
       /// between nodes and attributes.
       static rfl::Result<pugi::xml_node> cast_as_node(
-          const std::variant<pugi::xml_node, pugi::xml_attribute>&
-              _node_or_attribute
+        const std::variant<pugi::xml_node, pugi::xml_attribute>& _node_or_attribute
       ) {
         const auto cast = [](const auto& _n) -> Result<pugi::xml_node> {
           using Type = std::remove_cvref_t<decltype(_n)>;
           if constexpr (std::is_same<Type, pugi::xml_node>()) {
             return _n;
           } else {
-            return Error(
-                "Field '" + std::string(_n.name()) + "' is an attribute."
-            );
+            return Error("Field '" + std::string(_n.name()) + "' is an attribute.");
           }
         };
         return std::visit(cast, _node_or_attribute);
       }
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&    _name,
-          const InputObjectType _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType _obj)
+        const noexcept {
         const auto node = _obj.node_.child(_name.c_str());
         if (!node) {
           return rfl::Error("Object contains no field named '" + _name + "'.");
@@ -81,9 +76,7 @@ namespace rfl {
 
       bool is_empty(const InputVarType _var) const noexcept {
         const auto wrap = [](const auto& _node) { return !_node; };
-        return std::visit(cast_as_node, _var.node_or_attribute_)
-            .transform(wrap)
-            .value_or(false);
+        return std::visit(cast_as_node, _var.node_or_attribute_).transform(wrap).value_or(false);
       }
 
       template <class T>
@@ -106,39 +99,28 @@ namespace rfl {
           try {
             return static_cast<T>(std::stod(str));
           } catch (std::exception& e) {
-            return Error(
-                "Could not cast '" + std::string(str) +
-                "' to floating point value."
-            );
+            return Error("Could not cast '" + std::string(str) + "' to floating point value.");
           }
         } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
           const auto str = std::visit(get_value, _var.node_or_attribute_);
           try {
             return static_cast<T>(std::stoi(str));
           } catch (std::exception& e) {
-            return Error(
-                "Could not cast '" + std::string(str) + "' to integer."
-            );
+            return Error("Could not cast '" + std::string(str) + "' to integer.");
           }
         } else {
           static_assert(rfl::always_false_v<T>, "Unsupported type.");
         }
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType _var
-      ) const noexcept {
-        const auto wrap = [](const auto& _node) {
-          return InputArrayType(_node);
-        };
-        return std::visit(cast_as_node, _var.node_or_attribute_)
-            .transform(wrap);
+      rfl::Result<InputArrayType> to_array(const InputVarType _var) const noexcept {
+        const auto wrap = [](const auto& _node) { return InputArrayType(_node); };
+        return std::visit(cast_as_node, _var.node_or_attribute_).transform(wrap);
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         const auto name = _arr.node_.name();
         for (auto node = _arr.node_; node; node = node.next_sibling(name)) {
           const auto err = _array_reader.read(InputVarType(node));
@@ -150,45 +132,30 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
-        for (auto child = _obj.node_.first_child(); child;
-             child      = child.next_sibling()) {
-          _object_reader.read(
-              std::string_view(child.name()), InputVarType(child)
-          );
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
+        for (auto child = _obj.node_.first_child(); child; child = child.next_sibling()) {
+          _object_reader.read(std::string_view(child.name()), InputVarType(child));
         }
 
-        for (auto attr = _obj.node_.first_attribute(); attr;
-             attr      = attr.next_attribute()) {
-          _object_reader.read(
-              std::string_view(attr.name()), InputVarType(attr)
-          );
+        for (auto attr = _obj.node_.first_attribute(); attr; attr = attr.next_attribute()) {
+          _object_reader.read(std::string_view(attr.name()), InputVarType(attr));
         }
 
         if constexpr (parsing::is_view_reader_v<ObjectReader>) {
-          _object_reader.read(
-              std::string_view("xml_content"), InputVarType(_obj.node_)
-          );
+          _object_reader.read(std::string_view("xml_content"), InputVarType(_obj.node_));
         }
 
         return std::nullopt;
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType _var
-      ) const noexcept {
-        const auto wrap = [](const auto& _node) {
-          return InputObjectType(_node);
-        };
-        return std::visit(cast_as_node, _var.node_or_attribute_)
-            .transform(wrap);
+      rfl::Result<InputObjectType> to_object(const InputVarType _var) const noexcept {
+        const auto wrap = [](const auto& _node) { return InputObjectType(_node); };
+        return std::visit(cast_as_node, _var.node_or_attribute_).transform(wrap);
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType _var) const noexcept {
         return rfl::Error("TODO");
       }
     };
diff --git a/include/rfl/xml/Writer.hpp b/include/rfl/xml/Writer.hpp
index 9224e9e..1b573b7 100644
--- a/include/rfl/xml/Writer.hpp
+++ b/include/rfl/xml/Writer.hpp
@@ -22,11 +22,8 @@ namespace rfl {
       static constexpr const char* XML_CONTENT = "xml_content";
 
       struct XMLOutputArray {
-        XMLOutputArray(
-            const std::string_view&    _name,
-            const Ref<pugi::xml_node>& _node
-        )
-            : name_(_name), node_(_node) {}
+        XMLOutputArray(const std::string_view& _name, const Ref<pugi::xml_node>& _node)
+          : name_(_name), node_(_node) {}
         std::string_view    name_;
         Ref<pugi::xml_node> node_;
       };
@@ -46,128 +43,109 @@ namespace rfl {
       using OutputVarType    = XMLOutputVar;
 
       Writer(const Ref<pugi::xml_node>& _root, const std::string& _root_name)
-          : root_(_root), root_name_(_root_name) {}
+        : root_(_root), root_name_(_root_name) {}
 
       ~Writer() = default;
 
       OutputArrayType array_as_root(const size_t _size) const noexcept {
-        auto node_child =
-            Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+        auto node_child = Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
         return OutputArrayType(root_name_, node_child);
       }
 
       OutputObjectType object_as_root(const size_t _size) const noexcept {
-        auto node_child =
-            Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+        auto node_child = Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
         return OutputObjectType(node_child);
       }
 
       OutputVarType null_as_root() const noexcept {
-        auto node_child =
-            Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+        auto node_child = Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
         return OutputVarType(node_child);
       }
 
       template <class T>
       OutputVarType value_as_root(const T& _var) const noexcept {
-        const auto str = to_string(_var);
-        auto       node_child =
-            Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+        const auto str        = to_string(_var);
+        auto       node_child = Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
         node_child->append_child(pugi::node_pcdata).set_value(str.c_str());
         return OutputVarType(node_child);
       }
 
-      OutputArrayType add_array_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return *_parent;
       }
 
       OutputArrayType add_array_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         return OutputArrayType(_name, _parent->node_);
       }
 
-      OutputObjectType add_object_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
-        auto node_child = Ref<pugi::xml_node>::make(
-            _parent->node_->append_child(_parent->name_.data())
-        );
+      OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
+        auto node_child =
+          Ref<pugi::xml_node>::make(_parent->node_->append_child(_parent->name_.data()));
         return OutputObjectType(node_child);
       }
 
       OutputObjectType add_object_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
-        auto node_child =
-            Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data())
-            );
+        auto node_child = Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data()));
         return OutputObjectType(node_child);
       }
 
       template <class T>
-      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-          const noexcept {
-        const auto str        = to_string(_var);
-        auto       node_child = Ref<pugi::xml_node>::make(
-            _parent->node_->append_child(_parent->name_.data())
-        );
+      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
+        const auto str = to_string(_var);
+        auto       node_child =
+          Ref<pugi::xml_node>::make(_parent->node_->append_child(_parent->name_.data()));
         node_child->append_child(pugi::node_pcdata).set_value(str.c_str());
         return OutputVarType(node_child);
       }
 
       template <class T>
       OutputVarType add_value_to_object(
-          const std::string_view& _name,
-          const T&                _var,
-          OutputObjectType*       _parent,
-          const bool              _is_attribute = false
+        const std::string_view& _name,
+        const T&                _var,
+        OutputObjectType*       _parent,
+        const bool              _is_attribute = false
       ) const noexcept {
         const auto str = to_string(_var);
         if (_is_attribute) {
           _parent->node_->append_attribute(_name.data()) = str.c_str();
           return OutputVarType(_parent->node_);
         } else if (_name == XML_CONTENT) {
-          _parent->node_->append_child(pugi::node_pcdata)
-              .set_value(str.c_str());
+          _parent->node_->append_child(pugi::node_pcdata).set_value(str.c_str());
           return OutputVarType(_parent->node_);
         } else {
-          auto node_child = Ref<pugi::xml_node>::make(
-              _parent->node_->append_child(_name.data())
-          );
+          auto node_child = Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data()));
           node_child->append_child(pugi::node_pcdata).set_value(str.c_str());
           return OutputVarType(node_child);
         }
       }
 
       OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
-        auto node_child = Ref<pugi::xml_node>::make(
-            _parent->node_->append_child(_parent->name_.data())
-        );
+        auto node_child =
+          Ref<pugi::xml_node>::make(_parent->node_->append_child(_parent->name_.data()));
         return OutputVarType(node_child);
       }
 
       OutputVarType add_null_to_object(
-          const std::string_view& _name,
-          OutputObjectType*       _parent,
-          const bool              _is_attribute = false
+        const std::string_view& _name,
+        OutputObjectType*       _parent,
+        const bool              _is_attribute = false
       ) const noexcept {
         if (_is_attribute) {
           return OutputVarType(_parent->node_);
         } else if (_name == XML_CONTENT) {
           return OutputVarType(_parent->node_);
         } else {
-          auto node_child = Ref<pugi::xml_node>::make(
-              _parent->node_->append_child(_name.data())
-          );
+          auto node_child = Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data()));
           return OutputVarType(node_child);
         }
       }
diff --git a/include/rfl/xml/load.hpp b/include/rfl/xml/load.hpp
index 8cef454..7e7ac18 100644
--- a/include/rfl/xml/load.hpp
+++ b/include/rfl/xml/load.hpp
@@ -10,9 +10,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_string = [](const auto& _str) {
-        return read<T, Ps...>(_str);
-      };
+      const auto read_string = [](const auto& _str) { return read<T, Ps...>(_str); };
       return rfl::io::load_string(_fname).and_then(read_string);
     }
 
diff --git a/include/rfl/xml/read.hpp b/include/rfl/xml/read.hpp
index 465635b..b2b077c 100644
--- a/include/rfl/xml/read.hpp
+++ b/include/rfl/xml/read.hpp
@@ -29,10 +29,7 @@ namespace rfl {
       pugi::xml_document doc;
       const auto         result = doc.load_string(_xml_str.c_str());
       if (!result) {
-        return Error(
-            "XML string could not be parsed: " +
-            std::string(result.description())
-        );
+        return Error("XML string could not be parsed: " + std::string(result.description()));
       }
       const auto var = InputVarType(doc.first_child());
       return read<T, Ps...>(var);
@@ -41,10 +38,8 @@ namespace rfl {
     /// Parses an object from a stringstream.
     template <class T, class... Ps>
     auto read(std::istream& _stream) {
-      const auto xml_str = std::string(
-          std::istreambuf_iterator<char>(_stream),
-          std::istreambuf_iterator<char>()
-      );
+      const auto xml_str =
+        std::string(std::istreambuf_iterator<char>(_stream), std::istreambuf_iterator<char>());
       return read<T, Ps...>(xml_str);
     }
 
diff --git a/include/rfl/xml/save.hpp b/include/rfl/xml/save.hpp
index 8715e5d..202efeb 100644
--- a/include/rfl/xml/save.hpp
+++ b/include/rfl/xml/save.hpp
@@ -13,9 +13,7 @@
 namespace rfl {
   namespace xml {
 
-    template <
-        internal::StringLiteral _root = internal::StringLiteral(""),
-        class... Ps>
+    template <internal::StringLiteral _root = internal::StringLiteral(""), class... Ps>
     Result<Nothing> save(const std::string& _fname, const auto& _obj) {
       const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
         return write<_root, Ps...>(_obj, _stream);
diff --git a/include/rfl/xml/write.hpp b/include/rfl/xml/write.hpp
index 19479f2..f759454 100644
--- a/include/rfl/xml/write.hpp
+++ b/include/rfl/xml/write.hpp
@@ -22,45 +22,37 @@ namespace rfl {
       if constexpr (_root != internal::StringLiteral("")) {
         return _root;
       } else {
-        return internal::remove_namespaces<
-            internal::get_type_name<std::remove_cvref_t<T>>()>();
+        return internal::remove_namespaces<internal::get_type_name<std::remove_cvref_t<T>>()>();
       }
     }
 
     /// Writes a XML into an ostream.
-    template <
-        internal::StringLiteral _root = internal::StringLiteral(""),
-        class... Ps>
-    std::ostream& write(
-        const auto&        _obj,
-        std::ostream&      _stream,
-        const std::string& _indent = "    "
-    ) {
+    template <internal::StringLiteral _root = internal::StringLiteral(""), class... Ps>
+    std::ostream&
+    write(const auto& _obj, std::ostream& _stream, const std::string& _indent = "    ") {
       using T          = std::remove_cvref_t<decltype(_obj)>;
       using ParentType = parsing::Parent<Writer>;
 
       constexpr auto root_name = get_root_name<_root, T>();
 
       static_assert(
-          root_name.string_view().find("<") == std::string_view::npos &&
-              root_name.string_view().find(">") == std::string_view::npos,
-          "The name of an XML root node cannot contain '<' or '>'. "
-          "Please assign an "
-          "explicit root name to rfl::xml::write(...) like this: "
-          "rfl::xml::write<\"root_name\">(...)."
+        root_name.string_view().find("<") == std::string_view::npos &&
+          root_name.string_view().find(">") == std::string_view::npos,
+        "The name of an XML root node cannot contain '<' or '>'. "
+        "Please assign an "
+        "explicit root name to rfl::xml::write(...) like this: "
+        "rfl::xml::write<\"root_name\">(...)."
       );
 
       const auto doc = rfl::Ref<pugi::xml_document>::make();
 
-      auto declaration_node = doc->append_child(pugi::node_declaration);
+      auto declaration_node                         = doc->append_child(pugi::node_declaration);
       declaration_node.append_attribute("version")  = "1.0";
       declaration_node.append_attribute("encoding") = "UTF-8";
 
       auto w = Writer(doc, root_name.str());
 
-      Parser<T, Processors<Ps...>>::write(
-          w, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root {});
 
       doc->save(_stream, _indent.c_str());
 
@@ -68,9 +60,7 @@ namespace rfl {
     }
 
     /// Returns a XML string.
-    template <
-        internal::StringLiteral _root = internal::StringLiteral(""),
-        class... Ps>
+    template <internal::StringLiteral _root = internal::StringLiteral(""), class... Ps>
     std::string write(const auto& _obj, const std::string& _indent = "    ") {
       std::stringstream stream;
       write<_root, Ps...>(_obj, stream);
diff --git a/include/rfl/yaml/Reader.hpp b/include/rfl/yaml/Reader.hpp
index ead8b0a..2181211 100644
--- a/include/rfl/yaml/Reader.hpp
+++ b/include/rfl/yaml/Reader.hpp
@@ -45,12 +45,10 @@ namespace rfl {
 
       template <class T>
       static constexpr bool has_custom_constructor =
-          (requires(InputVarType var) { T::from_yaml_obj(var); });
+        (requires(InputVarType var) { T::from_yaml_obj(var); });
 
-      rfl::Result<InputVarType> get_field(
-          const std::string&     _name,
-          const InputObjectType& _obj
-      ) const noexcept {
+      rfl::Result<InputVarType> get_field(const std::string& _name, const InputObjectType& _obj)
+        const noexcept {
         auto var = InputVarType(_obj.node_[_name]);
         if (!var.node_) {
           return rfl::Error("Object contains no field named '" + _name + "'.");
@@ -58,9 +56,7 @@ namespace rfl {
         return var;
       }
 
-      bool is_empty(const InputVarType& _var) const noexcept {
-        return !_var.node_ && true;
-      }
+      bool is_empty(const InputVarType& _var) const noexcept { return !_var.node_ && true; }
 
       template <class T>
       rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
@@ -76,8 +72,7 @@ namespace rfl {
         } catch (std::exception& e) { return rfl::Error(e.what()); }
       }
 
-      rfl::Result<InputArrayType> to_array(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputArrayType> to_array(const InputVarType& _var) const noexcept {
         if (!_var.node_.IsSequence()) {
           return rfl::Error("Could not cast to sequence!");
         }
@@ -85,10 +80,8 @@ namespace rfl {
       }
 
       template <class ArrayReader>
-      std::optional<Error> read_array(
-          const ArrayReader&    _array_reader,
-          const InputArrayType& _arr
-      ) const noexcept {
+      std::optional<Error> read_array(const ArrayReader& _array_reader, const InputArrayType& _arr)
+        const noexcept {
         for (size_t i = 0; i < _arr.node_.size(); ++i) {
           const auto err = _array_reader.read(_arr.node_[i]);
           if (err) {
@@ -99,10 +92,8 @@ namespace rfl {
       }
 
       template <class ObjectReader>
-      std::optional<Error> read_object(
-          const ObjectReader&    _object_reader,
-          const InputObjectType& _obj
-      ) const noexcept {
+      std::optional<Error>
+      read_object(const ObjectReader& _object_reader, const InputObjectType& _obj) const noexcept {
         for (const auto& p : _obj.node_) {
           try {
             const auto k = p.first.as<std::string>();
@@ -112,8 +103,7 @@ namespace rfl {
         return std::nullopt;
       }
 
-      rfl::Result<InputObjectType> to_object(const InputVarType& _var
-      ) const noexcept {
+      rfl::Result<InputObjectType> to_object(const InputVarType& _var) const noexcept {
         if (!_var.node_.IsMap()) {
           return rfl::Error("Could not cast to map!");
         }
@@ -121,8 +111,7 @@ namespace rfl {
       }
 
       template <class T>
-      rfl::Result<T> use_custom_constructor(const InputVarType _var
-      ) const noexcept {
+      rfl::Result<T> use_custom_constructor(const InputVarType _var) const noexcept {
         try {
           return T::from_yaml_obj(_var);
         } catch (std::exception& e) { return rfl::Error(e.what()); }
diff --git a/include/rfl/yaml/Writer.hpp b/include/rfl/yaml/Writer.hpp
index 618cb38..657130c 100644
--- a/include/rfl/yaml/Writer.hpp
+++ b/include/rfl/yaml/Writer.hpp
@@ -34,64 +34,53 @@ namespace rfl {
 
       ~Writer() = default;
 
-      OutputArrayType array_as_root(const size_t _size) const noexcept {
-        return new_array();
-      }
+      OutputArrayType array_as_root(const size_t _size) const noexcept { return new_array(); }
 
-      OutputObjectType object_as_root(const size_t _size) const noexcept {
-        return new_object();
-      }
+      OutputObjectType object_as_root(const size_t _size) const noexcept { return new_object(); }
 
-      OutputVarType null_as_root() const noexcept {
-        return insert_value(YAML::Null);
-      }
+      OutputVarType null_as_root() const noexcept { return insert_value(YAML::Null); }
 
       template <class T>
       OutputVarType value_as_root(const T& _var) const noexcept {
         return insert_value(_var);
       }
 
-      OutputArrayType add_array_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputArrayType add_array_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return new_array();
       }
 
       OutputArrayType add_array_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         return new_array(_name);
       }
 
-      OutputObjectType add_object_to_array(
-          const size_t     _size,
-          OutputArrayType* _parent
-      ) const noexcept {
+      OutputObjectType add_object_to_array(const size_t _size, OutputArrayType* _parent)
+        const noexcept {
         return new_object();
       }
 
       OutputObjectType add_object_to_object(
-          const std::string_view& _name,
-          const size_t            _size,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const size_t            _size,
+        OutputObjectType*       _parent
       ) const noexcept {
         return new_object(_name);
       }
 
       template <class T>
-      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent)
-          const noexcept {
+      OutputVarType add_value_to_array(const T& _var, OutputArrayType* _parent) const noexcept {
         return insert_value(_var);
       }
 
       template <class T>
       OutputVarType add_value_to_object(
-          const std::string_view& _name,
-          const T&                _var,
-          OutputObjectType*       _parent
+        const std::string_view& _name,
+        const T&                _var,
+        OutputObjectType*       _parent
       ) const noexcept {
         return insert_value(_name, _var);
       }
@@ -100,25 +89,18 @@ namespace rfl {
         return insert_value(YAML::Null);
       }
 
-      OutputVarType add_null_to_object(
-          const std::string_view& _name,
-          OutputObjectType*       _parent
-      ) const noexcept {
+      OutputVarType add_null_to_object(const std::string_view& _name, OutputObjectType* _parent)
+        const noexcept {
         return insert_value(_name, YAML::Null);
       }
 
-      void end_array(OutputArrayType* _arr) const noexcept {
-        (*out_) << YAML::EndSeq;
-      }
+      void end_array(OutputArrayType* _arr) const noexcept { (*out_) << YAML::EndSeq; }
 
-      void end_object(OutputObjectType* _obj) const noexcept {
-        (*out_) << YAML::EndMap;
-      }
+      void end_object(OutputObjectType* _obj) const noexcept { (*out_) << YAML::EndMap; }
 
      private:
       template <class T>
-      OutputVarType insert_value(const std::string_view& _name, const T& _var)
-          const noexcept {
+      OutputVarType insert_value(const std::string_view& _name, const T& _var) const noexcept {
         (*out_) << YAML::Key << _name.data() << YAML::Value << _var;
         return OutputVarType {};
       }
@@ -139,8 +121,7 @@ namespace rfl {
         return OutputArrayType {};
       }
 
-      OutputObjectType new_object(const std::string_view& _name
-      ) const noexcept {
+      OutputObjectType new_object(const std::string_view& _name) const noexcept {
         (*out_) << YAML::Key << _name.data() << YAML::Value << YAML::BeginMap;
         return OutputObjectType {};
       }
diff --git a/include/rfl/yaml/load.hpp b/include/rfl/yaml/load.hpp
index b13cd66..81c6e73 100644
--- a/include/rfl/yaml/load.hpp
+++ b/include/rfl/yaml/load.hpp
@@ -10,9 +10,7 @@ namespace rfl {
 
     template <class T, class... Ps>
     Result<T> load(const std::string& _fname) {
-      const auto read_string = [](const auto& _str) {
-        return read<T, Ps...>(_str);
-      };
+      const auto read_string = [](const auto& _str) { return read<T, Ps...>(_str); };
       return rfl::io::load_string(_fname).and_then(read_string);
     }
 
diff --git a/include/rfl/yaml/read.hpp b/include/rfl/yaml/read.hpp
index 7b3ebd7..af31de0 100644
--- a/include/rfl/yaml/read.hpp
+++ b/include/rfl/yaml/read.hpp
@@ -23,8 +23,7 @@ namespace rfl {
 
     /// Parses an object from YAML using reflection.
     template <class T, class... Ps>
-    Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _yaml_str
-    ) {
+    Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _yaml_str) {
       try {
         const auto var = InputVarType(YAML::Load(_yaml_str));
         return read<T, Ps...>(var);
@@ -34,10 +33,8 @@ namespace rfl {
     /// Parses an object from a stringstream.
     template <class T, class... Ps>
     auto read(std::istream& _stream) {
-      const auto yaml_str = std::string(
-          std::istreambuf_iterator<char>(_stream),
-          std::istreambuf_iterator<char>()
-      );
+      const auto yaml_str =
+        std::string(std::istreambuf_iterator<char>(_stream), std::istreambuf_iterator<char>());
       return read<T, Ps...>(yaml_str);
     }
 
diff --git a/include/rfl/yaml/write.hpp b/include/rfl/yaml/write.hpp
index 5ee7d3b..48e2584 100644
--- a/include/rfl/yaml/write.hpp
+++ b/include/rfl/yaml/write.hpp
@@ -21,9 +21,7 @@ namespace rfl {
       using ParentType = parsing::Parent<Writer>;
       const auto out   = Ref<YAML::Emitter>::make();
       auto       w     = Writer(out);
-      Parser<T, Processors<Ps...>>::write(
-          w, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root {});
       _stream << out->c_str();
       return _stream;
     }
@@ -35,9 +33,7 @@ namespace rfl {
       using ParentType = parsing::Parent<Writer>;
       const auto out   = Ref<YAML::Emitter>::make();
       auto       w     = Writer(out);
-      Parser<T, Processors<Ps...>>::write(
-          w, _obj, typename ParentType::Root {}
-      );
+      Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root {});
       return out->c_str();
     }
 
diff --git a/include/util/macros.h b/include/util/macros.h
index 64be55e..0238467 100644
--- a/include/util/macros.h
+++ b/include/util/macros.h
@@ -9,22 +9,24 @@
  * @brief Allows for easy getter creation
  *
  * @param class_name The class to use
- * @param type Type of the getter
- * @param name Name of the getter
+ * @param type       Type of the getter
+ * @param name       Name of the getter
  */
 #define DEFINE_GETTER(class_name, type, name) \
-  fn class_name::get##name() const -> type { return m_##name; }
+  fn class_name::get##name() const->type { return m_##name; }
 
 /**
  * @brief Helper for making reflect-cpp impls
  *
  * @param struct_name The struct name
- * @param lower_name The arg name
- * @param ... Values of the class to convert
+ * @param lower_name  The arg name
+ * @param ...         Values of the class to convert
  */
-#define DEF_IMPL(struct_name, lower_name, ...)                                \
-  struct struct_name##Impl {                                                  \
-    __VA_ARGS__;                                                              \
-    static fn from_class(const struct_name& lower_name) -> struct_name##Impl; \
-    [[nodiscard]] fn to_class() const -> struct_name;                         \
+#define DEF_IMPL(struct_name, ...)                                                   \
+  struct struct_name##Impl {                                                         \
+    __VA_ARGS__;                                                                     \
+                                                                                     \
+    static fn from_class(const struct_name& instance) noexcept -> struct_name##Impl; \
+                                                                                     \
+    [[nodiscard]] fn to_class() const -> struct_name;                                \
   };
diff --git a/include/util/numtypes.h b/include/util/numtypes.h
index 86f957c..24a86c3 100644
--- a/include/util/numtypes.h
+++ b/include/util/numtypes.h
@@ -3,22 +3,117 @@
 #include <cstddef>
 #include <cstdint>
 
-// Unsigned integers
-using u8  = std::uint8_t;
+/**
+ * @typedef u8
+ * @brief Represents an 8-bit unsigned integer.
+ *
+ * This type alias is used for 8-bit unsigned integers, ranging from 0 to 255.
+ * It is based on the std::uint8_t type.
+ */
+using u8 = std::uint8_t;
+
+/**
+ * @typedef u16
+ * @brief Represents a 16-bit unsigned integer.
+ *
+ * This type alias is used for 16-bit unsigned integers, ranging from 0 to 65,535.
+ * It is based on the std::uint16_t type.
+ */
 using u16 = std::uint16_t;
+
+/**
+ * @typedef u32
+ * @brief Represents a 32-bit unsigned integer.
+ *
+ * This type alias is used for 32-bit unsigned integers, ranging from 0 to 4,294,967,295.
+ * It is based on the std::uint32_t type.
+ */
 using u32 = std::uint32_t;
+
+/**
+ * @typedef u64
+ * @brief Represents a 64-bit unsigned integer.
+ *
+ * This type alias is used for 64-bit unsigned integers, ranging from 0 to
+ * 18,446,744,073,709,551,615. It is based on the std::uint64_t type.
+ */
 using u64 = std::uint64_t;
 
-// Signed integers
-using i8  = std::int8_t;
+// Type Aliases for Signed Integers
+
+/**
+ * @typedef i8
+ * @brief Represents an 8-bit signed integer.
+ *
+ * This type alias is used for 8-bit signed integers, ranging from -128 to 127.
+ * It is based on the std::int8_t type.
+ */
+using i8 = std::int8_t;
+
+/**
+ * @typedef i16
+ * @brief Represents a 16-bit signed integer.
+ *
+ * This type alias is used for 16-bit signed integers, ranging from -32,768 to 32,767.
+ * It is based on the std::int16_t type.
+ */
 using i16 = std::int16_t;
+
+/**
+ * @typedef i32
+ * @brief Represents a 32-bit signed integer.
+ *
+ * This type alias is used for 32-bit signed integers, ranging from -2,147,483,648 to 2,147,483,647.
+ * It is based on the std::int32_t type.
+ */
 using i32 = std::int32_t;
+
+/**
+ * @typedef i64
+ * @brief Represents a 64-bit signed integer.
+ *
+ * This type alias is used for 64-bit signed integers, ranging from -9,223,372,036,854,775,808 to
+ * 9,223,372,036,854,775,807. It is based on the std::int64_t type.
+ */
 using i64 = std::int64_t;
 
-// Floating-points
+// Type Aliases for Floating-Point Numbers
+
+/**
+ * @typedef f32
+ * @brief Represents a 32-bit floating-point number.
+ *
+ * This type alias is used for 32-bit floating-point numbers, which follow the IEEE 754 standard.
+ * It is based on the float type.
+ */
 using f32 = float;
+
+/**
+ * @typedef f64
+ * @brief Represents a 64-bit floating-point number.
+ *
+ * This type alias is used for 64-bit floating-point numbers, which follow the IEEE 754 standard.
+ * It is based on the double type.
+ */
 using f64 = double;
 
-// Size types
+// Type Aliases for Size Types
+
+/**
+ * @typedef usize
+ * @brief Represents an unsigned size type.
+ *
+ * This type alias is used for representing the size of objects in bytes.
+ * It is based on the std::size_t type, which is the result type of the sizeof operator.
+ */
 using usize = std::size_t;
+
+/**
+ * @typedef isize
+ * @brief Represents a signed size type.
+ *
+ * This type alias is used for representing pointer differences.
+ * It is based on the std::ptrdiff_t type, which is the signed integer type returned when
+ * subtracting two pointers.
+ */
 using isize = std::ptrdiff_t;
diff --git a/include/util/result.h b/include/util/result.h
index 8975aa7..3641c9b 100644
--- a/include/util/result.h
+++ b/include/util/result.h
@@ -5,47 +5,99 @@
 #include <utility>
 #include <variant>
 
-#include "util/numtypes.h"
+#include "util/macros.h"
 
-// Define an error type
+/**
+ * @class Error
+ * @brief Represents an error with a message.
+ *
+ * This class is used to encapsulate error messages that can be returned from functions.
+ */
 class Error {
  public:
+  /**
+   * @brief Constructs an Error with a message.
+   * @param message The error message.
+   */
   explicit Error(std::string message) : m_Message(std::move(message)) {}
+
+  /**
+   * @brief Retrieves the error message.
+   * @return A constant reference to the error message string.
+   */
   [[nodiscard]] fn message() const -> const std::string& { return m_Message; }
 
  private:
-  std::string m_Message;
+  std::string m_Message; ///< The error message.
 };
 
 // Primary template for Result with a default type of void
+
+/**
+ * @class Result
+ * @brief Represents a result that can either be a value or an error.
+ *
+ * This is the primary template for Result, which defaults to handling void results.
+ */
 template <typename T = void>
 class Result;
 
 // Specialization for Result<void>
+
+/**
+ * @class Result<void>
+ * @brief Specialization of Result for handling void results.
+ *
+ * This class is used when a function either succeeds with no value or fails with an error.
+ */
 template <>
 class Result<void> {
  public:
-  // Constructors for success and error
+  /**
+   * @brief Constructs a successful Result.
+   */
   Result() : m_Result(std::monostate {}) {}
+
+  /**
+   * @brief Constructs an error Result.
+   * @param error The error object.
+   */
   Result(const Error& error) : m_Result(error) {}
+
+  /**
+   * @brief Constructs an error Result.
+   * @param error An rvalue reference to the error object.
+   */
   Result(Error&& error) : m_Result(std::move(error)) {}
 
-  // Check if the result is an error
-  [[nodiscard]] fn isOk() const -> bool {
-    return std::holds_alternative<std::monostate>(m_Result);
-  }
-  [[nodiscard]] fn isErr() const -> bool {
-    return std::holds_alternative<Error>(m_Result);
-  }
+  /**
+   * @brief Checks if the Result is successful.
+   * @return True if the Result is successful, otherwise false.
+   */
+  [[nodiscard]] fn isOk() const -> bool { return std::holds_alternative<std::monostate>(m_Result); }
 
-  // Throw an exception if it is an error
+  /**
+   * @brief Checks if the Result contains an error.
+   * @return True if the Result contains an error, otherwise false.
+   */
+  [[nodiscard]] fn isErr() const -> bool { return std::holds_alternative<Error>(m_Result); }
+
+  /**
+   * @brief Throws an exception if the Result contains an error.
+   *
+   * This function should be called only if the Result is successful.
+   */
   void value() const {
     if (isErr()) {
       throw std::logic_error("Attempted to access value of an error Result");
     }
   }
 
-  // Get the error or throw an exception if it is a value
+  /**
+   * @brief Retrieves the error object.
+   * @return A constant reference to the Error object.
+   * @throws std::logic_error if the Result is successful.
+   */
   [[nodiscard]] fn error() const -> const Error& {
     if (isOk()) {
       throw std::logic_error("Attempted to access error of an ok Result");
@@ -54,28 +106,63 @@ class Result<void> {
   }
 
  private:
-  std::variant<std::monostate, Error> m_Result;
+  std::variant<std::monostate, Error>
+    m_Result; ///< The underlying result, which can be either void or an Error.
 };
 
 // Primary template for Result
+
+/**
+ * @class Result
+ * @brief Represents a result that can either be a value of type T or an error.
+ *
+ * This template class is used to handle results that can either be a successful value or an error.
+ * @tparam T The type of the successful value.
+ */
 template <typename T>
 class Result {
  public:
-  // Constructors for success and error
+  /**
+   * @brief Constructs a successful Result with a value.
+   * @param value The value of the Result.
+   */
   Result(const T& value) : m_Result(value) {}
+
+  /**
+   * @brief Constructs a successful Result with a value.
+   * @param value An rvalue reference to the value.
+   */
   Result(T&& value) : m_Result(std::move(value)) {}
+
+  /**
+   * @brief Constructs an error Result.
+   * @param error The error object.
+   */
   Result(const Error& error) : m_Result(error) {}
+
+  /**
+   * @brief Constructs an error Result.
+   * @param error An rvalue reference to the error object.
+   */
   Result(Error&& error) : m_Result(std::move(error)) {}
 
-  // Check if the result is an error
-  [[nodiscard]] fn isOk() const -> bool {
-    return std::holds_alternative<T>(m_Result);
-  }
-  [[nodiscard]] fn isErr() const -> bool {
-    return std::holds_alternative<Error>(m_Result);
-  }
+  /**
+   * @brief Checks if the Result is successful.
+   * @return True if the Result is successful, otherwise false.
+   */
+  [[nodiscard]] fn isOk() const -> bool { return std::holds_alternative<T>(m_Result); }
 
-  // Get the value or throw an exception if it is an error
+  /**
+   * @brief Checks if the Result contains an error.
+   * @return True if the Result contains an error, otherwise false.
+   */
+  [[nodiscard]] fn isErr() const -> bool { return std::holds_alternative<Error>(m_Result); }
+
+  /**
+   * @brief Retrieves the value.
+   * @return A constant reference to the value.
+   * @throws std::logic_error if the Result contains an error.
+   */
   fn value() const -> const T& {
     if (isErr()) {
       throw std::logic_error("Attempted to access value of an error Result");
@@ -83,7 +170,11 @@ class Result {
     return std::get<T>(m_Result);
   }
 
-  // Get the error or throw an exception if it is a value
+  /**
+   * @brief Retrieves the error object.
+   * @return A constant reference to the Error object.
+   * @throws std::logic_error if the Result is successful.
+   */
   [[nodiscard]] fn error() const -> const Error& {
     if (isOk()) {
       throw std::logic_error("Attempted to access error of an ok Result");
@@ -91,18 +182,37 @@ class Result {
     return std::get<Error>(m_Result);
   }
 
-  // Optional: Get the value or provide a default
+  /**
+   * @brief Retrieves the value or returns a default value.
+   * @param defaultValue The default value to return if the Result contains an error.
+   * @return The value if the Result is successful, otherwise the default value.
+   */
   fn valueOr(const T& defaultValue) const -> T {
     return isOk() ? std::get<T>(m_Result) : defaultValue;
   }
 
  private:
-  std::variant<T, Error> m_Result;
+  std::variant<T, Error>
+    m_Result; ///< The underlying result, which can be either a value of type T or an Error.
 };
 
+/**
+ * @brief Helper function to create a successful Result.
+ *
+ * This function deduces the type of the value and creates a successful Result.
+ * @tparam T The type of the value.
+ * @param value The value to be stored in the Result.
+ * @return A Result object containing the value.
+ */
 template <typename T>
 fn Ok(T&& value) {
   return Result<std::decay_t<T>>(std::forward<T>(value));
 }
 
+/**
+ * @brief Helper function to create a successful Result<void>.
+ *
+ * This function creates a successful Result that does not contain a value.
+ * @return A Result<void> object indicating success.
+ */
 inline fn Ok() -> Result<void> { return {}; }
diff --git a/include/yyjson.h b/include/yyjson.h
index e1ee159..04c5cf6 100644
--- a/include/yyjson.h
+++ b/include/yyjson.h
@@ -248,8 +248,7 @@
 
 /** likely for compiler */
 #ifndef yyjson_likely
-#if yyjson_has_builtin(__builtin_expect) || \
-    (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
+#if yyjson_has_builtin(__builtin_expect) || (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
 #define yyjson_likely(expr) __builtin_expect(!!(expr), 1)
 #else
 #define yyjson_likely(expr) (expr)
@@ -258,8 +257,7 @@
 
 /** unlikely for compiler */
 #ifndef yyjson_unlikely
-#if yyjson_has_builtin(__builtin_expect) || \
-    (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
+#if yyjson_has_builtin(__builtin_expect) || (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
 #define yyjson_unlikely(expr) __builtin_expect(!!(expr), 0)
 #else
 #define yyjson_unlikely(expr) (expr)
@@ -271,7 +269,7 @@
 #if YYJSON_MSC_VER >= 1400
 #define yyjson_deprecated(msg) __declspec(deprecated(msg))
 #elif yyjson_has_feature(attribute_deprecated_with_message) || \
-    (YYJSON_GCC_VER > 4 || (YYJSON_GCC_VER == 4 && __GNUC_MINOR__ >= 5))
+  (YYJSON_GCC_VER > 4 || (YYJSON_GCC_VER == 4 && __GNUC_MINOR__ >= 5))
 #define yyjson_deprecated(msg) __attribute__((deprecated(msg)))
 #elif YYJSON_GCC_VER >= 3
 #define yyjson_deprecated(msg) __attribute__((deprecated))
@@ -303,10 +301,9 @@
 #endif
 
 /** stdint (C89 compatible) */
-#if (defined(YYJSON_HAS_STDINT_H) && YYJSON_HAS_STDINT_H) ||                  \
-    YYJSON_MSC_VER >= 1600 || YYJSON_STDC_VER >= 199901L ||                   \
-    defined(_STDINT_H) || defined(_STDINT_H_) || defined(__CLANG_STDINT_H) || \
-    defined(_STDINT_H_INCLUDED) || yyjson_has_include(<stdint.h>)
+#if (defined(YYJSON_HAS_STDINT_H) && YYJSON_HAS_STDINT_H) || YYJSON_MSC_VER >= 1600 || \
+  YYJSON_STDC_VER >= 199901L || defined(_STDINT_H) || defined(_STDINT_H_) ||           \
+  defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || yyjson_has_include(<stdint.h>)
 #include <stdint.h>
 #elif defined(_MSC_VER)
 #if _MSC_VER < 1300
@@ -364,12 +361,12 @@ typedef __UINT64_TYPE__ uint64_t;
 __extension__ typedef long long int64_t;
 #endif
 __extension__ typedef unsigned long long uint64_t;
-#elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \
-    defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+#elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || defined(__SUNPRO_C) || \
+  defined(__SUNPRO_CC)
 typedef long long          int64_t;
 typedef unsigned long long uint64_t;
-#elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \
-    defined(__WATCOM_INT64__) || defined(__alpha) || defined(__DECC)
+#elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || defined(__WATCOM_INT64__) || \
+  defined(__alpha) || defined(__DECC)
 typedef __int64          int64_t;
 typedef unsigned __int64 uint64_t;
 #else
@@ -378,9 +375,9 @@ typedef unsigned __int64 uint64_t;
 #endif
 
 /** stdbool (C89 compatible) */
-#if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) ||        \
-    (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__)) || \
-    YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L
+#if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) ||                                \
+  (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__)) || YYJSON_MSC_VER >= 1800 || \
+  YYJSON_STDC_VER >= 199901L
 #include <stdbool.h>
 #elif !defined(__bool_true_false_are_defined)
 #define __bool_true_false_are_defined 1
@@ -737,11 +734,11 @@ extern "C" {
       When it's no longer needed, it should be freed with `yyjson_doc_free()`.
    */
   yyjson_api yyjson_doc* yyjson_read_opts(
-      char*             dat,
-      size_t            len,
-      yyjson_read_flag  flg,
-      const yyjson_alc* alc,
-      yyjson_read_err*  err
+    char*             dat,
+    size_t            len,
+    yyjson_read_flag  flg,
+    const yyjson_alc* alc,
+    yyjson_read_err*  err
   );
 
   /**
@@ -765,10 +762,10 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to read.
    */
   yyjson_api yyjson_doc* yyjson_read_file(
-      const char*       path,
-      yyjson_read_flag  flg,
-      const yyjson_alc* alc,
-      yyjson_read_err*  err
+    const char*       path,
+    yyjson_read_flag  flg,
+    const yyjson_alc* alc,
+    yyjson_read_err*  err
   );
 
   /**
@@ -788,12 +785,8 @@ extern "C" {
 
    @warning On 32-bit operating system, files larger than 2GB may fail to read.
    */
-  yyjson_api yyjson_doc* yyjson_read_fp(
-      FILE*             fp,
-      yyjson_read_flag  flg,
-      const yyjson_alc* alc,
-      yyjson_read_err*  err
-  );
+  yyjson_api yyjson_doc*
+  yyjson_read_fp(FILE* fp, yyjson_read_flag flg, const yyjson_alc* alc, yyjson_read_err* err);
 
   /**
    Read a JSON string.
@@ -809,12 +802,9 @@ extern "C" {
    @return A new JSON document, or NULL if an error occurs.
       When it's no longer needed, it should be freed with `yyjson_doc_free()`.
    */
-  yyjson_api_inline yyjson_doc*
-  yyjson_read(const char* dat, size_t len, yyjson_read_flag flg) {
+  yyjson_api_inline yyjson_doc* yyjson_read(const char* dat, size_t len, yyjson_read_flag flg) {
     flg &= ~YYJSON_READ_INSITU; /* const string cannot be modified */
-    return yyjson_read_opts(
-        (char*)(void*)(size_t)(const void*)dat, len, flg, NULL, NULL
-    );
+    return yyjson_read_opts((char*)(void*)(size_t)(const void*)dat, len, flg, NULL, NULL);
   }
 
   /**
@@ -854,8 +844,7 @@ extern "C" {
    @endcode
    @see yyjson_alc_pool_init()
    */
-  yyjson_api_inline size_t
-  yyjson_read_max_memory_usage(size_t len, yyjson_read_flag flg) {
+  yyjson_api_inline size_t yyjson_read_max_memory_usage(size_t len, yyjson_read_flag flg) {
     /*
      1. The max value count is (json_size / 2 + 1),
         for example: "[1,2,3,4]" size is 9, value count is 5.
@@ -898,11 +887,11 @@ extern "C" {
       used in the conversion, NULL if an error occurs.
    */
   yyjson_api const char* yyjson_read_number(
-      const char*       dat,
-      yyjson_val*       val,
-      yyjson_read_flag  flg,
-      const yyjson_alc* alc,
-      yyjson_read_err*  err
+    const char*       dat,
+    yyjson_val*       val,
+    yyjson_read_flag  flg,
+    const yyjson_alc* alc,
+    yyjson_read_err*  err
   );
 
   /**
@@ -927,11 +916,11 @@ extern "C" {
       used in the conversion, NULL if an error occurs.
    */
   yyjson_api_inline const char* yyjson_mut_read_number(
-      const char*       dat,
-      yyjson_mut_val*   val,
-      yyjson_read_flag  flg,
-      const yyjson_alc* alc,
-      yyjson_read_err*  err
+    const char*       dat,
+    yyjson_mut_val*   val,
+    yyjson_read_flag  flg,
+    const yyjson_alc* alc,
+    yyjson_read_err*  err
   ) {
     return yyjson_read_number(dat, (yyjson_val*)val, flg, alc, err);
   }
@@ -1039,11 +1028,11 @@ extern "C" {
       When it's no longer needed, it should be freed with free() or alc->free().
    */
   yyjson_api char* yyjson_write_opts(
-      const yyjson_doc* doc,
-      yyjson_write_flag flg,
-      const yyjson_alc* alc,
-      size_t*           len,
-      yyjson_write_err* err
+    const yyjson_doc* doc,
+    yyjson_write_flag flg,
+    const yyjson_alc* alc,
+    size_t*           len,
+    yyjson_write_err* err
   );
 
   /**
@@ -1070,11 +1059,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_write_file(
-      const char*       path,
-      const yyjson_doc* doc,
-      yyjson_write_flag flg,
-      const yyjson_alc* alc,
-      yyjson_write_err* err
+    const char*       path,
+    const yyjson_doc* doc,
+    yyjson_write_flag flg,
+    const yyjson_alc* alc,
+    yyjson_write_err* err
   );
 
   /**
@@ -1097,11 +1086,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_write_fp(
-      FILE*             fp,
-      const yyjson_doc* doc,
-      yyjson_write_flag flg,
-      const yyjson_alc* alc,
-      yyjson_write_err* err
+    FILE*             fp,
+    const yyjson_doc* doc,
+    yyjson_write_flag flg,
+    const yyjson_alc* alc,
+    yyjson_write_err* err
   );
 
   /**
@@ -1120,8 +1109,7 @@ extern "C" {
       This string is encoded as UTF-8 with a null-terminator.
       When it's no longer needed, it should be freed with free().
    */
-  yyjson_api_inline char*
-  yyjson_write(const yyjson_doc* doc, yyjson_write_flag flg, size_t* len) {
+  yyjson_api_inline char* yyjson_write(const yyjson_doc* doc, yyjson_write_flag flg, size_t* len) {
     return yyjson_write_opts(doc, flg, NULL, len, NULL);
   }
 
@@ -1148,11 +1136,11 @@ extern "C" {
       When it's no longer needed, it should be freed with free() or alc->free().
    */
   yyjson_api char* yyjson_mut_write_opts(
-      const yyjson_mut_doc* doc,
-      yyjson_write_flag     flg,
-      const yyjson_alc*     alc,
-      size_t*               len,
-      yyjson_write_err*     err
+    const yyjson_mut_doc* doc,
+    yyjson_write_flag     flg,
+    const yyjson_alc*     alc,
+    size_t*               len,
+    yyjson_write_err*     err
   );
 
   /**
@@ -1180,11 +1168,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_mut_write_file(
-      const char*           path,
-      const yyjson_mut_doc* doc,
-      yyjson_write_flag     flg,
-      const yyjson_alc*     alc,
-      yyjson_write_err*     err
+    const char*           path,
+    const yyjson_mut_doc* doc,
+    yyjson_write_flag     flg,
+    const yyjson_alc*     alc,
+    yyjson_write_err*     err
   );
 
   /**
@@ -1207,11 +1195,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_mut_write_fp(
-      FILE*                 fp,
-      const yyjson_mut_doc* doc,
-      yyjson_write_flag     flg,
-      const yyjson_alc*     alc,
-      yyjson_write_err*     err
+    FILE*                 fp,
+    const yyjson_mut_doc* doc,
+    yyjson_write_flag     flg,
+    const yyjson_alc*     alc,
+    yyjson_write_err*     err
   );
 
   /**
@@ -1231,11 +1219,8 @@ extern "C" {
       This string is encoded as UTF-8 with a null-terminator.
       When it's no longer needed, it should be freed with free().
    */
-  yyjson_api_inline char* yyjson_mut_write(
-      const yyjson_mut_doc* doc,
-      yyjson_write_flag     flg,
-      size_t*               len
-  ) {
+  yyjson_api_inline char*
+  yyjson_mut_write(const yyjson_mut_doc* doc, yyjson_write_flag flg, size_t* len) {
     return yyjson_mut_write_opts(doc, flg, NULL, len, NULL);
   }
 
@@ -1264,11 +1249,11 @@ extern "C" {
       When it's no longer needed, it should be freed with free() or alc->free().
    */
   yyjson_api char* yyjson_val_write_opts(
-      const yyjson_val* val,
-      yyjson_write_flag flg,
-      const yyjson_alc* alc,
-      size_t*           len,
-      yyjson_write_err* err
+    const yyjson_val* val,
+    yyjson_write_flag flg,
+    const yyjson_alc* alc,
+    size_t*           len,
+    yyjson_write_err* err
   );
 
   /**
@@ -1294,11 +1279,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_val_write_file(
-      const char*       path,
-      const yyjson_val* val,
-      yyjson_write_flag flg,
-      const yyjson_alc* alc,
-      yyjson_write_err* err
+    const char*       path,
+    const yyjson_val* val,
+    yyjson_write_flag flg,
+    const yyjson_alc* alc,
+    yyjson_write_err* err
   );
 
   /**
@@ -1320,11 +1305,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_val_write_fp(
-      FILE*             fp,
-      const yyjson_val* val,
-      yyjson_write_flag flg,
-      const yyjson_alc* alc,
-      yyjson_write_err* err
+    FILE*             fp,
+    const yyjson_val* val,
+    yyjson_write_flag flg,
+    const yyjson_alc* alc,
+    yyjson_write_err* err
   );
 
   /**
@@ -1369,11 +1354,11 @@ extern "C" {
       When it's no longer needed, it should be freed with free() or alc->free().
    */
   yyjson_api char* yyjson_mut_val_write_opts(
-      const yyjson_mut_val* val,
-      yyjson_write_flag     flg,
-      const yyjson_alc*     alc,
-      size_t*               len,
-      yyjson_write_err*     err
+    const yyjson_mut_val* val,
+    yyjson_write_flag     flg,
+    const yyjson_alc*     alc,
+    size_t*               len,
+    yyjson_write_err*     err
   );
 
   /**
@@ -1400,11 +1385,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_mut_val_write_file(
-      const char*           path,
-      const yyjson_mut_val* val,
-      yyjson_write_flag     flg,
-      const yyjson_alc*     alc,
-      yyjson_write_err*     err
+    const char*           path,
+    const yyjson_mut_val* val,
+    yyjson_write_flag     flg,
+    const yyjson_alc*     alc,
+    yyjson_write_err*     err
   );
 
   /**
@@ -1426,11 +1411,11 @@ extern "C" {
    @warning On 32-bit operating system, files larger than 2GB may fail to write.
    */
   yyjson_api bool yyjson_mut_val_write_fp(
-      FILE*                 fp,
-      const yyjson_mut_val* val,
-      yyjson_write_flag     flg,
-      const yyjson_alc*     alc,
-      yyjson_write_err*     err
+    FILE*                 fp,
+    const yyjson_mut_val* val,
+    yyjson_write_flag     flg,
+    const yyjson_alc*     alc,
+    yyjson_write_err*     err
   );
 
   /**
@@ -1449,11 +1434,8 @@ extern "C" {
       This string is encoded as UTF-8 with a null-terminator.
       When it's no longer needed, it should be freed with free().
    */
-  yyjson_api_inline char* yyjson_mut_val_write(
-      const yyjson_mut_val* val,
-      yyjson_write_flag     flg,
-      size_t*               len
-  ) {
+  yyjson_api_inline char*
+  yyjson_mut_val_write(const yyjson_mut_val* val, yyjson_write_flag flg, size_t* len) {
     return yyjson_mut_val_write_opts(val, flg, NULL, len, NULL);
   }
 
@@ -1604,8 +1586,7 @@ extern "C" {
   /** Returns whether the JSON value is equals to a string.
       The `str` should be a UTF-8 string, null-terminator is not required.
       Returns false if input is NULL or type is not string. */
-  yyjson_api_inline bool
-  yyjson_equals_strn(yyjson_val* val, const char* str, size_t len);
+  yyjson_api_inline bool yyjson_equals_strn(yyjson_val* val, const char* str, size_t len);
 
   /** Returns whether two JSON values are equal (deep compare).
       Returns false if input is NULL.
@@ -1617,8 +1598,7 @@ extern "C" {
   /** Set the value to raw.
       Returns false if input is NULL or `val` is object or array.
       @warning This will modify the `immutable` value, use with caution. */
-  yyjson_api_inline bool
-  yyjson_set_raw(yyjson_val* val, const char* raw, size_t len);
+  yyjson_api_inline bool yyjson_set_raw(yyjson_val* val, const char* raw, size_t len);
 
   /** Set the value to null.
       Returns false if input is NULL or `val` is object or array.
@@ -1658,8 +1638,7 @@ extern "C" {
   /** Set the value to string (with length).
       Returns false if input is NULL or `val` is object or array.
       @warning This will modify the `immutable` value, use with caution. */
-  yyjson_api_inline bool
-  yyjson_set_strn(yyjson_val* val, const char* str, size_t len);
+  yyjson_api_inline bool yyjson_set_strn(yyjson_val* val, const char* str, size_t len);
 
   /*==============================================================================
    * JSON Array API
@@ -1718,8 +1697,7 @@ extern "C" {
 
    @note The iterator does not need to be destroyed.
    */
-  yyjson_api_inline bool
-  yyjson_arr_iter_init(yyjson_val* arr, yyjson_arr_iter* iter);
+  yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val* arr, yyjson_arr_iter* iter);
 
   /**
    Create an iterator with an array , same as `yyjson_arr_iter_init()`.
@@ -1758,11 +1736,8 @@ extern "C" {
     }
  @endcode
  */
-#define yyjson_arr_foreach(arr, idx, max, val) \
-  for ((idx) = 0,                              \
-      (max)  = yyjson_arr_size(arr),           \
-      (val)  = yyjson_arr_get_first(arr);      \
-       (idx) < (max);                          \
+#define yyjson_arr_foreach(arr, idx, max, val)                                                    \
+  for ((idx) = 0, (max) = yyjson_arr_size(arr), (val) = yyjson_arr_get_first(arr); (idx) < (max); \
        (idx)++, (val) = unsafe_yyjson_get_next(val))
 
   /*==============================================================================
@@ -1780,8 +1755,7 @@ extern "C" {
       The `key` should be a null-terminated UTF-8 string.
 
       @warning This function takes a linear search time. */
-  yyjson_api_inline yyjson_val*
-  yyjson_obj_get(yyjson_val* obj, const char* key);
+  yyjson_api_inline yyjson_val* yyjson_obj_get(yyjson_val* obj, const char* key);
 
   /** Returns the value to which the specified key is mapped.
       Returns NULL if this object contains no mapping for the key.
@@ -1791,8 +1765,7 @@ extern "C" {
       The `key_len` should be the length of the key, in bytes.
 
       @warning This function takes a linear search time. */
-  yyjson_api_inline yyjson_val*
-  yyjson_obj_getn(yyjson_val* obj, const char* key, size_t key_len);
+  yyjson_api_inline yyjson_val* yyjson_obj_getn(yyjson_val* obj, const char* key, size_t key_len);
 
   /*==============================================================================
    * JSON Object Iterator API
@@ -1840,8 +1813,7 @@ extern "C" {
 
    @note The iterator does not need to be destroyed.
    */
-  yyjson_api_inline bool
-  yyjson_obj_iter_init(yyjson_val* obj, yyjson_obj_iter* iter);
+  yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val* obj, yyjson_obj_iter* iter);
 
   /**
    Create an iterator with an object, same as `yyjson_obj_iter_init()`.
@@ -1889,8 +1861,7 @@ extern "C" {
 
    @warning This function takes a linear search time if the key is not nearby.
    */
-  yyjson_api_inline yyjson_val*
-  yyjson_obj_iter_get(yyjson_obj_iter* iter, const char* key);
+  yyjson_api_inline yyjson_val* yyjson_obj_iter_get(yyjson_obj_iter* iter, const char* key);
 
   /**
    Iterates to a specified key and returns the value.
@@ -1940,13 +1911,11 @@ extern "C" {
 
   /** Returns the root value of this JSON document.
       Returns NULL if `doc` is NULL. */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_get_root(yyjson_mut_doc* doc
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_get_root(yyjson_mut_doc* doc);
 
   /** Sets the root value of this JSON document.
       Pass NULL to clear root value of the document. */
-  yyjson_api_inline void
-  yyjson_mut_doc_set_root(yyjson_mut_doc* doc, yyjson_mut_val* root);
+  yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc* doc, yyjson_mut_val* root);
 
   /**
    Set the string pool size for a mutable document.
@@ -1961,8 +1930,7 @@ extern "C" {
    @param len The desired string pool size in bytes (total string length).
    @return true if successful, false if size is 0 or overflow.
    */
-  yyjson_api bool
-  yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc* doc, size_t len);
+  yyjson_api bool yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc* doc, size_t len);
 
   /**
    Set the value pool size for a mutable document.
@@ -1977,8 +1945,7 @@ extern "C" {
    @param count The desired value pool size (number of `yyjson_mut_val`).
    @return true if successful, false if size is 0 or overflow.
    */
-  yyjson_api bool
-  yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc* doc, size_t count);
+  yyjson_api bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc* doc, size_t count);
 
   /** Release the JSON document and free the memory.
       After calling this function, the `doc` and all values from the `doc` are
@@ -1993,22 +1960,19 @@ extern "C" {
      error. This makes a `deep-copy` on the immutable document. If allocator is
      NULL, the default allocator will be used.
       @note `imut_doc` -> `mut_doc`. */
-  yyjson_api yyjson_mut_doc*
-  yyjson_doc_mut_copy(yyjson_doc* doc, const yyjson_alc* alc);
+  yyjson_api yyjson_mut_doc* yyjson_doc_mut_copy(yyjson_doc* doc, const yyjson_alc* alc);
 
   /** Copies and returns a new mutable document from input, returns NULL on
      error. This makes a `deep-copy` on the mutable document. If allocator is
      NULL, the default allocator will be used.
       @note `mut_doc` -> `mut_doc`. */
-  yyjson_api yyjson_mut_doc*
-  yyjson_mut_doc_mut_copy(yyjson_mut_doc* doc, const yyjson_alc* alc);
+  yyjson_api yyjson_mut_doc* yyjson_mut_doc_mut_copy(yyjson_mut_doc* doc, const yyjson_alc* alc);
 
   /** Copies and returns a new mutable value from input, returns NULL on error.
       This makes a `deep-copy` on the immutable value.
       The memory was managed by mutable document.
       @note `imut_val` -> `mut_val`. */
-  yyjson_api yyjson_mut_val*
-  yyjson_val_mut_copy(yyjson_mut_doc* doc, yyjson_val* val);
+  yyjson_api yyjson_mut_val* yyjson_val_mut_copy(yyjson_mut_doc* doc, yyjson_val* val);
 
   /** Copies and returns a new mutable value from input, returns NULL on error.
       This makes a `deep-copy` on the mutable value.
@@ -2016,8 +1980,7 @@ extern "C" {
       @note `mut_val` -> `mut_val`.
       @warning This function is recursive and may cause a stack overflow
           if the object level is too deep. */
-  yyjson_api yyjson_mut_val*
-  yyjson_mut_val_mut_copy(yyjson_mut_doc* doc, yyjson_mut_val* val);
+  yyjson_api yyjson_mut_val* yyjson_mut_val_mut_copy(yyjson_mut_doc* doc, yyjson_mut_val* val);
 
   /** Copies and returns a new immutable document from input,
       returns NULL on error. This makes a `deep-copy` on the mutable document.
@@ -2025,8 +1988,7 @@ extern "C" {
       @note `mut_doc` -> `imut_doc`.
       @warning This function is recursive and may cause a stack overflow
           if the object level is too deep. */
-  yyjson_api yyjson_doc*
-  yyjson_mut_doc_imut_copy(yyjson_mut_doc* doc, const yyjson_alc* alc);
+  yyjson_api yyjson_doc* yyjson_mut_doc_imut_copy(yyjson_mut_doc* doc, const yyjson_alc* alc);
 
   /** Copies and returns a new immutable document from input,
       returns NULL on error. This makes a `deep-copy` on the mutable value.
@@ -2034,8 +1996,7 @@ extern "C" {
       @note `mut_val` -> `imut_doc`.
       @warning This function is recursive and may cause a stack overflow
           if the object level is too deep. */
-  yyjson_api yyjson_doc*
-  yyjson_mut_val_imut_copy(yyjson_mut_val* val, const yyjson_alc* alc);
+  yyjson_api yyjson_doc* yyjson_mut_val_imut_copy(yyjson_mut_val* val, const yyjson_alc* alc);
 
   /*==============================================================================
    * Mutable JSON Value Type API
@@ -2157,29 +2118,25 @@ extern "C" {
   /** Returns whether the JSON value is equals to a string.
       The `str` should be a null-terminated UTF-8 string.
       Returns false if input is NULL or type is not string. */
-  yyjson_api_inline bool
-  yyjson_mut_equals_str(yyjson_mut_val* val, const char* str);
+  yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val* val, const char* str);
 
   /** Returns whether the JSON value is equals to a string.
       The `str` should be a UTF-8 string, null-terminator is not required.
       Returns false if input is NULL or type is not string. */
-  yyjson_api_inline bool
-  yyjson_mut_equals_strn(yyjson_mut_val* val, const char* str, size_t len);
+  yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val* val, const char* str, size_t len);
 
   /** Returns whether two JSON values are equal (deep compare).
       Returns false if input is NULL.
       @note the result may be inaccurate if object has duplicate keys.
       @warning This function is recursive and may cause a stack overflow
           if the object level is too deep. */
-  yyjson_api_inline bool
-  yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs);
+  yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs);
 
   /** Set the value to raw.
       Returns false if input is NULL.
       @warning This function should not be used on an existing object or array.
    */
-  yyjson_api_inline bool
-  yyjson_mut_set_raw(yyjson_mut_val* val, const char* raw, size_t len);
+  yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val* val, const char* raw, size_t len);
 
   /** Set the value to null.
       Returns false if input is NULL.
@@ -2221,15 +2178,13 @@ extern "C" {
       Returns false if input is NULL.
       @warning This function should not be used on an existing object or array.
    */
-  yyjson_api_inline bool
-  yyjson_mut_set_str(yyjson_mut_val* val, const char* str);
+  yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val* val, const char* str);
 
   /** Set the value to string (with length).
       Returns false if input is NULL.
       @warning This function should not be used on an existing object or array.
    */
-  yyjson_api_inline bool
-  yyjson_mut_set_strn(yyjson_mut_val* val, const char* str, size_t len);
+  yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val* val, const char* str, size_t len);
 
   /** Set the value to array.
       Returns false if input is NULL.
@@ -2252,8 +2207,7 @@ extern "C" {
 
       @warning The input string is not copied, you should keep this string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_raw(yyjson_mut_doc* doc, const char* str);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_raw(yyjson_mut_doc* doc, const char* str);
 
   /** Creates and returns a raw value, returns NULL on error.
       The `str` should be a UTF-8 string, null-terminator is not required.
@@ -2266,8 +2220,7 @@ extern "C" {
   /** Creates and returns a raw value, returns NULL on error.
       The `str` should be a null-terminated UTF-8 string.
       The input string is copied and held by the document. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_rawcpy(yyjson_mut_doc* doc, const char* str);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_rawcpy(yyjson_mut_doc* doc, const char* str);
 
   /** Creates and returns a raw value, returns NULL on error.
       The `str` should be a UTF-8 string, null-terminator is not required.
@@ -2285,31 +2238,25 @@ extern "C" {
   yyjson_api_inline yyjson_mut_val* yyjson_mut_false(yyjson_mut_doc* doc);
 
   /** Creates and returns a bool value, returns NULL on error. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_bool(yyjson_mut_doc* doc, bool val);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_bool(yyjson_mut_doc* doc, bool val);
 
   /** Creates and returns an unsigned integer value, returns NULL on error. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_uint(yyjson_mut_doc* doc, uint64_t num);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_uint(yyjson_mut_doc* doc, uint64_t num);
 
   /** Creates and returns a signed integer value, returns NULL on error. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_sint(yyjson_mut_doc* doc, int64_t num);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_sint(yyjson_mut_doc* doc, int64_t num);
 
   /** Creates and returns a signed integer value, returns NULL on error. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_int(yyjson_mut_doc* doc, int64_t num);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_int(yyjson_mut_doc* doc, int64_t num);
 
   /** Creates and returns an real number value, returns NULL on error. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_real(yyjson_mut_doc* doc, double num);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_real(yyjson_mut_doc* doc, double num);
 
   /** Creates and returns a string value, returns NULL on error.
       The `str` should be a null-terminated UTF-8 string.
       @warning The input string is not copied, you should keep this string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_str(yyjson_mut_doc* doc, const char* str);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_str(yyjson_mut_doc* doc, const char* str);
 
   /** Creates and returns a string value, returns NULL on error.
       The `str` should be a UTF-8 string, null-terminator is not required.
@@ -2321,8 +2268,7 @@ extern "C" {
   /** Creates and returns a string value, returns NULL on error.
       The `str` should be a null-terminated UTF-8 string.
       The input string is copied and held by the document. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_strcpy(yyjson_mut_doc* doc, const char* str);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_strcpy(yyjson_mut_doc* doc, const char* str);
 
   /** Creates and returns a string value, returns NULL on error.
       The `str` should be a UTF-8 string, null-terminator is not required.
@@ -2341,18 +2287,15 @@ extern "C" {
   /** Returns the element at the specified position in this array.
       Returns NULL if array is NULL/empty or the index is out of bounds.
       @warning This function takes a linear search time. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_arr_get(yyjson_mut_val* arr, size_t idx);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get(yyjson_mut_val* arr, size_t idx);
 
   /** Returns the first element of this array.
       Returns NULL if `arr` is NULL/empty or type is not array. */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_first(yyjson_mut_val* arr
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_first(yyjson_mut_val* arr);
 
   /** Returns the last element of this array.
       Returns NULL if `arr` is NULL/empty or type is not array. */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_last(yyjson_mut_val* arr
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_last(yyjson_mut_val* arr);
 
   /*==============================================================================
    * Mutable JSON Array Iterator API
@@ -2395,8 +2338,7 @@ extern "C" {
 
    @note The iterator does not need to be destroyed.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_iter_init(yyjson_mut_val* arr, yyjson_mut_arr_iter* iter);
+  yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val* arr, yyjson_mut_arr_iter* iter);
 
   /**
    Create an iterator with an array , same as `yyjson_mut_arr_iter_init()`.
@@ -2408,31 +2350,25 @@ extern "C" {
 
    @note The iterator does not need to be destroyed.
    */
-  yyjson_api_inline yyjson_mut_arr_iter
-  yyjson_mut_arr_iter_with(yyjson_mut_val* arr);
+  yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with(yyjson_mut_val* arr);
 
   /**
    Returns whether the iteration has more elements.
    If `iter` is NULL, this function will return false.
    */
-  yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter* iter
-  );
+  yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter* iter);
 
   /**
    Returns the next element in the iteration, or NULL on end.
    If `iter` is NULL, this function will return NULL.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_next(
-      yyjson_mut_arr_iter* iter
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_next(yyjson_mut_arr_iter* iter);
 
   /**
    Removes and returns current element in the iteration.
    If `iter` is NULL, this function will return NULL.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_remove(
-      yyjson_mut_arr_iter* iter
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_remove(yyjson_mut_arr_iter* iter);
 
 /**
  Macro for iterating over an array.
@@ -2449,11 +2385,9 @@ extern "C" {
     }
  @endcode
  */
-#define yyjson_mut_arr_foreach(arr, idx, max, val) \
-  for ((idx) = 0,                                  \
-      (max)  = yyjson_mut_arr_size(arr),           \
-      (val)  = yyjson_mut_arr_get_first(arr);      \
-       (idx) < (max);                              \
+#define yyjson_mut_arr_foreach(arr, idx, max, val)                                         \
+  for ((idx) = 0, (max) = yyjson_mut_arr_size(arr), (val) = yyjson_mut_arr_get_first(arr); \
+       (idx) < (max);                                                                      \
        (idx)++, (val) = (val)->next)
 
   /*==============================================================================
@@ -2501,11 +2435,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint(
-      yyjson_mut_doc* doc,
-      const int64_t*  vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint(yyjson_mut_doc* doc, const int64_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given uint numbers.
@@ -2523,11 +2454,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_uint(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint(
-      yyjson_mut_doc* doc,
-      const uint64_t* vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint(yyjson_mut_doc* doc, const uint64_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given real numbers.
@@ -2545,11 +2473,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_real(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_real(
-      yyjson_mut_doc* doc,
-      const double*   vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_real(yyjson_mut_doc* doc, const double* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given int8 numbers.
@@ -2567,11 +2492,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_sint8(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint8(
-      yyjson_mut_doc* doc,
-      const int8_t*   vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint8(yyjson_mut_doc* doc, const int8_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given int16 numbers.
@@ -2589,11 +2511,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_sint16(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint16(
-      yyjson_mut_doc* doc,
-      const int16_t*  vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint16(yyjson_mut_doc* doc, const int16_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given int32 numbers.
@@ -2611,11 +2530,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_sint32(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint32(
-      yyjson_mut_doc* doc,
-      const int32_t*  vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint32(yyjson_mut_doc* doc, const int32_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given int64 numbers.
@@ -2633,11 +2549,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint64(
-      yyjson_mut_doc* doc,
-      const int64_t*  vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint64(yyjson_mut_doc* doc, const int64_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given uint8 numbers.
@@ -2655,11 +2568,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_uint8(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint8(
-      yyjson_mut_doc* doc,
-      const uint8_t*  vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint8(yyjson_mut_doc* doc, const uint8_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given uint16 numbers.
@@ -2677,11 +2587,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_uint16(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint16(
-      yyjson_mut_doc* doc,
-      const uint16_t* vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint16(yyjson_mut_doc* doc, const uint16_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given uint32 numbers.
@@ -2699,11 +2606,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_uint32(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint32(
-      yyjson_mut_doc* doc,
-      const uint32_t* vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint32(yyjson_mut_doc* doc, const uint32_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given uint64 numbers.
@@ -2721,11 +2625,8 @@ extern "C" {
        yyjson_mut_val *arr = yyjson_mut_arr_with_uint64(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint64(
-      yyjson_mut_doc* doc,
-      const uint64_t* vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint64(yyjson_mut_doc* doc, const uint64_t* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given float numbers.
@@ -2743,11 +2644,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_float(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_float(
-      yyjson_mut_doc* doc,
-      const float*    vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_float(yyjson_mut_doc* doc, const float* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given double numbers.
@@ -2765,11 +2663,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_double(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_double(
-      yyjson_mut_doc* doc,
-      const double*   vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_double(yyjson_mut_doc* doc, const double* vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given strings, these strings
@@ -2821,10 +2716,10 @@ extern "C" {
    @endcode
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_strn(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      const size_t*   lens,
-      size_t          count
+    yyjson_mut_doc* doc,
+    const char**    vals,
+    const size_t*   lens,
+    size_t          count
   );
 
   /**
@@ -2845,11 +2740,8 @@ extern "C" {
       yyjson_mut_val *arr = yyjson_mut_arr_with_strcpy(doc, vals, 3);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_strcpy(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_strcpy(yyjson_mut_doc* doc, const char** vals, size_t count);
 
   /**
    Creates and returns a new mutable array with the given strings and string
@@ -2872,10 +2764,10 @@ extern "C" {
    @endcode
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_strncpy(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      const size_t*   lens,
-      size_t          count
+    yyjson_mut_doc* doc,
+    const char**    vals,
+    const size_t*   lens,
+    size_t          count
   );
 
   /*==============================================================================
@@ -2902,8 +2794,7 @@ extern "C" {
    @param val The value to be inserted. Returns false if it is NULL.
    @return Whether successful.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_append(yyjson_mut_val* arr, yyjson_mut_val* val);
+  yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val* arr, yyjson_mut_val* val);
 
   /**
    Inserts a value at the head of the array.
@@ -2912,8 +2803,7 @@ extern "C" {
    @param val The value to be inserted. Returns false if it is NULL.
    @return    Whether successful.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_prepend(yyjson_mut_val* arr, yyjson_mut_val* val);
+  yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val* arr, yyjson_mut_val* val);
 
   /**
    Replaces a value at index and returns old value.
@@ -2937,8 +2827,7 @@ extern "C" {
    @return Old value, or NULL on error.
    @warning This function takes a linear search time.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_arr_remove(yyjson_mut_val* arr, size_t idx);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove(yyjson_mut_val* arr, size_t idx);
 
   /**
    Removes and returns the first value in this array.
@@ -2946,9 +2835,7 @@ extern "C" {
       Returns false if it is NULL or not an array.
    @return The first value, or NULL on error.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_first(
-      yyjson_mut_val* arr
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_first(yyjson_mut_val* arr);
 
   /**
    Removes and returns the last value in this array.
@@ -2956,9 +2843,7 @@ extern "C" {
       Returns false if it is NULL or not an array.
    @return The last value, or NULL on error.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_last(
-      yyjson_mut_val* arr
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_last(yyjson_mut_val* arr);
 
   /**
    Removes all values within a specified range in the array.
@@ -2969,8 +2854,7 @@ extern "C" {
    @return Whether successful.
    @warning This function takes a linear search time.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_remove_range(yyjson_mut_val* arr, size_t idx, size_t len);
+  yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val* arr, size_t idx, size_t len);
 
   /**
    Removes all values in this array.
@@ -3000,8 +2884,7 @@ extern "C" {
    @param val The value to be inserted. Returns false if it is NULL.
    @return Whether successful.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_val(yyjson_mut_val* arr, yyjson_mut_val* val);
+  yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val* arr, yyjson_mut_val* val);
 
   /**
    Adds a `null` value at the end of the array.
@@ -3010,8 +2893,7 @@ extern "C" {
       Returns false if it is NULL or not an array.
    @return Whether successful.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_null(yyjson_mut_doc* doc, yyjson_mut_val* arr);
+  yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc* doc, yyjson_mut_val* arr);
 
   /**
    Adds a `true` value at the end of the array.
@@ -3020,8 +2902,7 @@ extern "C" {
       Returns false if it is NULL or not an array.
    @return Whether successful.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_true(yyjson_mut_doc* doc, yyjson_mut_val* arr);
+  yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc* doc, yyjson_mut_val* arr);
 
   /**
    Adds a `false` value at the end of the array.
@@ -3030,8 +2911,7 @@ extern "C" {
       Returns false if it is NULL or not an array.
    @return Whether successful.
    */
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_false(yyjson_mut_doc* doc, yyjson_mut_val* arr);
+  yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc* doc, yyjson_mut_val* arr);
 
   /**
    Adds a bool value at the end of the array.
@@ -3052,11 +2932,8 @@ extern "C" {
    @param num The number to be added.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_arr_add_uint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      uint64_t        num
-  );
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_uint(yyjson_mut_doc* doc, yyjson_mut_val* arr, uint64_t num);
 
   /**
    Adds a signed integer value at the end of the array.
@@ -3066,11 +2943,8 @@ extern "C" {
    @param num The number to be added.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_arr_add_sint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      int64_t         num
-  );
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_sint(yyjson_mut_doc* doc, yyjson_mut_val* arr, int64_t num);
 
   /**
    Adds a integer value at the end of the array.
@@ -3104,11 +2978,8 @@ extern "C" {
    @warning The input string is not copied, you should keep this string
    unmodified for the lifetime of this JSON document.
    */
-  yyjson_api_inline bool yyjson_mut_arr_add_str(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str
-  );
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_str(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str);
 
   /**
    Adds a string value at the end of the array (no copy).
@@ -3121,12 +2992,8 @@ extern "C" {
    @warning The input string is not copied, you should keep this string
    unmodified for the lifetime of this JSON document.
    */
-  yyjson_api_inline bool yyjson_mut_arr_add_strn(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str,
-      size_t          len
-  );
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_strn(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str, size_t len);
 
   /**
    Adds a string value at the end of the array (copied).
@@ -3136,11 +3003,8 @@ extern "C" {
    @param str A null-terminated UTF-8 string.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_arr_add_strcpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str
-  );
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_strcpy(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str);
 
   /**
    Adds a string value at the end of the array (copied).
@@ -3151,12 +3015,8 @@ extern "C" {
    @param len The length of the string, in bytes.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_arr_add_strncpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str,
-      size_t          len
-  );
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_strncpy(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str, size_t len);
 
   /**
    Creates and adds a new array at the end of the array.
@@ -3193,8 +3053,7 @@ extern "C" {
       The `key` should be a null-terminated UTF-8 string.
 
       @warning This function takes a linear search time. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_obj_get(yyjson_mut_val* obj, const char* key);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_get(yyjson_mut_val* obj, const char* key);
 
   /** Returns the value to which the specified key is mapped.
       Returns NULL if this object contains no mapping for the key.
@@ -3260,8 +3119,7 @@ extern "C" {
 
    @note The iterator does not need to be destroyed.
    */
-  yyjson_api_inline bool
-  yyjson_mut_obj_iter_init(yyjson_mut_val* obj, yyjson_mut_obj_iter* iter);
+  yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val* obj, yyjson_mut_obj_iter* iter);
 
   /**
    Create an iterator with an object, same as `yyjson_obj_iter_init()`.
@@ -3273,39 +3131,31 @@ extern "C" {
 
    @note The iterator does not need to be destroyed.
    */
-  yyjson_api_inline yyjson_mut_obj_iter
-  yyjson_mut_obj_iter_with(yyjson_mut_val* obj);
+  yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with(yyjson_mut_val* obj);
 
   /**
    Returns whether the iteration has more elements.
    If `iter` is NULL, this function will return false.
    */
-  yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter* iter
-  );
+  yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter* iter);
 
   /**
    Returns the next key in the iteration, or NULL on end.
    If `iter` is NULL, this function will return NULL.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_next(
-      yyjson_mut_obj_iter* iter
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_next(yyjson_mut_obj_iter* iter);
 
   /**
    Returns the value for key inside the iteration.
    If `iter` is NULL, this function will return NULL.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_get_val(
-      yyjson_mut_val* key
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_get_val(yyjson_mut_val* key);
 
   /**
    Removes current key-value pair in the iteration, returns the removed value.
    If `iter` is NULL, this function will return NULL.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_remove(
-      yyjson_mut_obj_iter* iter
-  );
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_remove(yyjson_mut_obj_iter* iter);
 
   /**
    Iterates to a specified key and returns the value.
@@ -3344,11 +3194,8 @@ extern "C" {
 
    @warning This function takes a linear search time if the key is not nearby.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_getn(
-      yyjson_mut_obj_iter* iter,
-      const char*          key,
-      size_t               key_len
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_iter_getn(yyjson_mut_obj_iter* iter, const char* key, size_t key_len);
 
 /**
  Macro for iterating over an object.
@@ -3395,12 +3242,8 @@ extern "C" {
       yyjson_mut_val *obj = yyjson_mut_obj_with_str(doc, keys, vals, 2);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_with_str(
-      yyjson_mut_doc* doc,
-      const char**    keys,
-      const char**    vals,
-      size_t          count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_with_str(yyjson_mut_doc* doc, const char** keys, const char** vals, size_t count);
 
   /**
    Creates and returns a mutable object with key-value pairs and pair count,
@@ -3416,11 +3259,8 @@ extern "C" {
       yyjson_mut_val *obj = yyjson_mut_obj_with_kv(doc, kv_pairs, 2);
    @endcode
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_with_kv(
-      yyjson_mut_doc* doc,
-      const char**    kv_pairs,
-      size_t          pair_count
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_with_kv(yyjson_mut_doc* doc, const char** kv_pairs, size_t pair_count);
 
   /*==============================================================================
    * Mutable JSON Object Modification API
@@ -3436,11 +3276,8 @@ extern "C" {
    @param val The value to add to the object.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_obj_add(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val);
   /**
    Sets a key-value pair at the end of the object.
    This function may remove all key-value pairs for the given key before add.
@@ -3452,11 +3289,8 @@ extern "C" {
    behavior is same as `yyjson_mut_obj_remove()`.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_obj_put(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_put(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val);
 
   /**
    Inserts a key-value pair to the object at the given position.
@@ -3469,12 +3303,8 @@ extern "C" {
    @param idx The index to which to insert the new pair.
    @return Whether successful.
    */
-  yyjson_api_inline bool yyjson_mut_obj_insert(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val,
-      size_t          idx
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_insert(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val, size_t idx);
 
   /**
    Removes all key-value pair from the object with given key.
@@ -3483,8 +3313,7 @@ extern "C" {
    @return The first matched value, or NULL if no matched value.
    @warning This function takes a linear search time.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_obj_remove(yyjson_mut_val* obj, yyjson_mut_val* key);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_remove(yyjson_mut_val* obj, yyjson_mut_val* key);
 
   /**
    Removes all key-value pair from the object with given key.
@@ -3493,8 +3322,7 @@ extern "C" {
    @return The first matched value, or NULL if no matched value.
    @warning This function takes a linear search time.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_obj_remove_key(yyjson_mut_val* obj, const char* key);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_remove_key(yyjson_mut_val* obj, const char* key);
 
   /**
    Removes all key-value pair from the object with given key.
@@ -3505,11 +3333,8 @@ extern "C" {
    @return The first matched value, or NULL if no matched value.
    @warning This function takes a linear search time.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_remove_keyn(
-      yyjson_mut_val* obj,
-      const char*     key,
-      size_t          key_len
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_remove_keyn(yyjson_mut_val* obj, const char* key, size_t key_len);
 
   /**
    Removes all key-value pairs in this object.
@@ -3527,11 +3352,8 @@ extern "C" {
    @return Whether successful.
    @warning This function takes a linear search time.
    */
-  yyjson_api_inline bool yyjson_mut_obj_replace(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_replace(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val);
 
   /**
    Rotates key-value pairs in the object for the given number of times.
@@ -3554,11 +3376,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_null(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_null(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key);
 
   /** Adds a `true` value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3566,11 +3385,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_true(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_true(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key);
 
   /** Adds a `false` value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3578,11 +3394,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_false(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_false(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key);
 
   /** Adds a bool value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3590,12 +3403,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_bool(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      bool            val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_bool(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key, bool val);
 
   /** Adds an unsigned integer value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3603,12 +3412,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_uint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      uint64_t        val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_uint(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key, uint64_t val);
 
   /** Adds a signed integer value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3616,12 +3421,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_sint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      int64_t         val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_sint(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key, int64_t val);
 
   /** Adds an int value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3629,12 +3430,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_int(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      int64_t         val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_int(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key, int64_t val);
 
   /** Adds a double value at the end of the object.
       The `key` should be a null-terminated UTF-8 string.
@@ -3642,12 +3439,8 @@ extern "C" {
 
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
-  yyjson_api_inline bool yyjson_mut_obj_add_real(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      double          val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_real(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* key, double val);
 
   /** Adds a string value at the end of the object.
       The `key` and `val` should be null-terminated UTF-8 strings.
@@ -3656,10 +3449,10 @@ extern "C" {
       @warning The key/value string are not copied, you should keep these
      strings unmodified for the lifetime of this JSON document. */
   yyjson_api_inline bool yyjson_mut_obj_add_str(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      const char*     val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    const char*     val
   );
 
   /** Adds a string value at the end of the object.
@@ -3671,11 +3464,11 @@ extern "C" {
       @warning The key/value string are not copied, you should keep these
      strings unmodified for the lifetime of this JSON document. */
   yyjson_api_inline bool yyjson_mut_obj_add_strn(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      const char*     val,
-      size_t          len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    const char*     val,
+    size_t          len
   );
 
   /** Adds a string value at the end of the object.
@@ -3686,10 +3479,10 @@ extern "C" {
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
   yyjson_api_inline bool yyjson_mut_obj_add_strcpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      const char*     val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    const char*     val
   );
 
   /** Adds a string value at the end of the object.
@@ -3701,11 +3494,11 @@ extern "C" {
       @warning The key/value string are not copied, you should keep these
      strings unmodified for the lifetime of this JSON document. */
   yyjson_api_inline bool yyjson_mut_obj_add_strncpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      const char*     val,
-      size_t          len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    const char*     val,
+    size_t          len
   );
 
   /** Adds a JSON value at the end of the object.
@@ -3715,10 +3508,10 @@ extern "C" {
       @warning The key string are not copied, you should keep the string
           unmodified for the lifetime of this JSON document. */
   yyjson_api_inline bool yyjson_mut_obj_add_val(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      yyjson_mut_val* val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    yyjson_mut_val* val
   );
 
   /** Removes all key-value pairs for the given key.
@@ -3727,8 +3520,7 @@ extern "C" {
      null-terminated UTF-8 string.
 
       @warning This function takes a linear search time. */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_obj_remove_str(yyjson_mut_val* obj, const char* key);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_remove_str(yyjson_mut_val* obj, const char* key);
 
   /** Removes all key-value pairs for the given key.
       Returns the first value to which the specified key is mapped or NULL if
@@ -3749,10 +3541,10 @@ extern "C" {
       If `new_key` already exists, it will cause duplicate keys.
    */
   yyjson_api_inline bool yyjson_mut_obj_rename_key(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      const char*     new_key
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    const char*     new_key
   );
 
   /** Replaces all matching keys with the new key.
@@ -3764,12 +3556,12 @@ extern "C" {
       If `new_key` already exists, it will cause duplicate keys.
    */
   yyjson_api_inline bool yyjson_mut_obj_rename_keyn(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      size_t          len,
-      const char*     new_key,
-      size_t          new_len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    size_t          len,
+    const char*     new_key,
+    size_t          new_len
   );
 
   /*==============================================================================
@@ -3862,8 +3654,7 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_val*
-  yyjson_doc_ptr_get(yyjson_doc* doc, const char* ptr);
+  yyjson_api_inline yyjson_val* yyjson_doc_ptr_get(yyjson_doc* doc, const char* ptr);
 
   /**
    Get value by a JSON Pointer.
@@ -3873,8 +3664,7 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_val*
-  yyjson_doc_ptr_getn(yyjson_doc* doc, const char* ptr, size_t len);
+  yyjson_api_inline yyjson_val* yyjson_doc_ptr_getn(yyjson_doc* doc, const char* ptr, size_t len);
 
   /**
    Get value by a JSON Pointer.
@@ -3885,12 +3675,8 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_val* yyjson_doc_ptr_getx(
-      yyjson_doc*     doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_err* err
-  );
+  yyjson_api_inline yyjson_val*
+  yyjson_doc_ptr_getx(yyjson_doc* doc, const char* ptr, size_t len, yyjson_ptr_err* err);
 
   /**
    Get value by a JSON Pointer.
@@ -3899,8 +3685,7 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_val*
-  yyjson_ptr_get(yyjson_val* val, const char* ptr);
+  yyjson_api_inline yyjson_val* yyjson_ptr_get(yyjson_val* val, const char* ptr);
 
   /**
    Get value by a JSON Pointer.
@@ -3910,8 +3695,7 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_val*
-  yyjson_ptr_getn(yyjson_val* val, const char* ptr, size_t len);
+  yyjson_api_inline yyjson_val* yyjson_ptr_getn(yyjson_val* val, const char* ptr, size_t len);
 
   /**
    Get value by a JSON Pointer.
@@ -3922,12 +3706,8 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_val* yyjson_ptr_getx(
-      yyjson_val*     val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_err* err
-  );
+  yyjson_api_inline yyjson_val*
+  yyjson_ptr_getx(yyjson_val* val, const char* ptr, size_t len, yyjson_ptr_err* err);
 
   /**
    Get value by a JSON Pointer.
@@ -3936,8 +3716,7 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_doc_ptr_get(yyjson_mut_doc* doc, const char* ptr);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_get(yyjson_mut_doc* doc, const char* ptr);
 
   /**
    Get value by a JSON Pointer.
@@ -3961,11 +3740,11 @@ extern "C" {
       NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_getx(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -3975,8 +3754,7 @@ extern "C" {
    @return The value referenced by the JSON pointer.
       NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_ptr_get(yyjson_mut_val* val, const char* ptr);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_get(yyjson_mut_val* val, const char* ptr);
 
   /**
    Get value by a JSON Pointer.
@@ -4000,11 +3778,11 @@ extern "C" {
       NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_getx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4016,11 +3794,8 @@ extern "C" {
    otherwise.
    @note The parent nodes will be created if they do not exist.
    */
-  yyjson_api_inline bool yyjson_mut_doc_ptr_add(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_doc_ptr_add(yyjson_mut_doc* doc, const char* ptr, yyjson_mut_val* new_val);
 
   /**
    Add (insert) value by a JSON pointer.
@@ -4033,10 +3808,10 @@ extern "C" {
    @note The parent nodes will be created if they do not exist.
    */
   yyjson_api_inline bool yyjson_mut_doc_ptr_addn(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   );
 
   /**
@@ -4052,13 +3827,13 @@ extern "C" {
    otherwise.
    */
   yyjson_api_inline bool yyjson_mut_doc_ptr_addx(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4072,10 +3847,10 @@ extern "C" {
    @note The parent nodes will be created if they do not exist.
    */
   yyjson_api_inline bool yyjson_mut_ptr_add(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   );
 
   /**
@@ -4090,11 +3865,11 @@ extern "C" {
    @note The parent nodes will be created if they do not exist.
    */
   yyjson_api_inline bool yyjson_mut_ptr_addn(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   );
 
   /**
@@ -4111,14 +3886,14 @@ extern "C" {
    otherwise.
    */
   yyjson_api_inline bool yyjson_mut_ptr_addx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4130,11 +3905,8 @@ extern "C" {
    @note The parent nodes will be created if they do not exist.
       If the target value already exists, it will be replaced by the new value.
    */
-  yyjson_api_inline bool yyjson_mut_doc_ptr_set(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  );
+  yyjson_api_inline bool
+  yyjson_mut_doc_ptr_set(yyjson_mut_doc* doc, const char* ptr, yyjson_mut_val* new_val);
 
   /**
    Set value by a JSON pointer.
@@ -4147,10 +3919,10 @@ extern "C" {
       If the target value already exists, it will be replaced by the new value.
    */
   yyjson_api_inline bool yyjson_mut_doc_ptr_setn(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   );
 
   /**
@@ -4167,13 +3939,13 @@ extern "C" {
    value.
    */
   yyjson_api_inline bool yyjson_mut_doc_ptr_setx(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4187,10 +3959,10 @@ extern "C" {
       If the target value already exists, it will be replaced by the new value.
    */
   yyjson_api_inline bool yyjson_mut_ptr_set(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   );
 
   /**
@@ -4205,11 +3977,11 @@ extern "C" {
       If the target value already exists, it will be replaced by the new value.
    */
   yyjson_api_inline bool yyjson_mut_ptr_setn(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   );
 
   /**
@@ -4227,14 +3999,14 @@ extern "C" {
    value.
    */
   yyjson_api_inline bool yyjson_mut_ptr_setx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4244,11 +4016,8 @@ extern "C" {
    @param new_val The new value to replace the old one.
    @return The old value that was replaced, or NULL if not found.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_replace(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_doc_ptr_replace(yyjson_mut_doc* doc, const char* ptr, yyjson_mut_val* new_val);
 
   /**
    Replace value by a JSON pointer.
@@ -4259,10 +4028,10 @@ extern "C" {
    @return The old value that was replaced, or NULL if not found.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_replacen(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   );
 
   /**
@@ -4276,12 +4045,12 @@ extern "C" {
    @return The old value that was replaced, or NULL if not found.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_replacex(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4291,11 +4060,8 @@ extern "C" {
    @param new_val The new value to replace the old one.
    @return The old value that was replaced, or NULL if not found.
    */
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_replace(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  );
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_ptr_replace(yyjson_mut_val* val, const char* ptr, yyjson_mut_val* new_val);
 
   /**
    Replace value by a JSON pointer.
@@ -4306,10 +4072,10 @@ extern "C" {
    @return The old value that was replaced, or NULL if not found.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_replacen(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   );
 
   /**
@@ -4323,12 +4089,12 @@ extern "C" {
    @return The old value that was replaced, or NULL if not found.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_replacex(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4337,8 +4103,7 @@ extern "C" {
    @param ptr The JSON pointer string (UTF-8 with null-terminator).
    @return The removed value, or NULL on error.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_doc_ptr_remove(yyjson_mut_doc* doc, const char* ptr);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_remove(yyjson_mut_doc* doc, const char* ptr);
 
   /**
    Remove value by a JSON pointer.
@@ -4360,11 +4125,11 @@ extern "C" {
    @return The removed value, or NULL on error.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_removex(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4373,8 +4138,7 @@ extern "C" {
    @param ptr The JSON pointer string (UTF-8 with null-terminator).
    @return The removed value, or NULL on error.
    */
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_ptr_remove(yyjson_mut_val* val, const char* ptr);
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_remove(yyjson_mut_val* val, const char* ptr);
 
   /**
    Remove value by a JSON pointer.
@@ -4396,11 +4160,11 @@ extern "C" {
    @return The removed value, or NULL on error.
    */
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_removex(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /**
@@ -4410,11 +4174,8 @@ extern "C" {
    @param val New value to be added.
    @return true on success or false on fail.
    */
-  yyjson_api_inline bool yyjson_ptr_ctx_append(
-      yyjson_ptr_ctx* ctx,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  );
+  yyjson_api_inline bool
+  yyjson_ptr_ctx_append(yyjson_ptr_ctx* ctx, yyjson_mut_val* key, yyjson_mut_val* val);
 
   /**
    Replace value by JSON pointer context.
@@ -4423,8 +4184,7 @@ extern "C" {
    @return true on success or false on fail.
    @note If success, the old value will be returned via `ctx->old`.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_ctx_replace(yyjson_ptr_ctx* ctx, yyjson_mut_val* val);
+  yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx* ctx, yyjson_mut_val* val);
 
   /**
    Remove value by JSON pointer context.
@@ -4484,12 +4244,8 @@ extern "C" {
    The `err` is used to receive error information, pass NULL if not needed.
    Returns NULL if the patch could not be applied.
    */
-  yyjson_api yyjson_mut_val* yyjson_patch(
-      yyjson_mut_doc*   doc,
-      yyjson_val*       orig,
-      yyjson_val*       patch,
-      yyjson_patch_err* err
-  );
+  yyjson_api yyjson_mut_val*
+  yyjson_patch(yyjson_mut_doc* doc, yyjson_val* orig, yyjson_val* patch, yyjson_patch_err* err);
 
   /**
    Creates and returns a patched JSON value (RFC 6902).
@@ -4498,10 +4254,10 @@ extern "C" {
    Returns NULL if the patch could not be applied.
    */
   yyjson_api yyjson_mut_val* yyjson_mut_patch(
-      yyjson_mut_doc*   doc,
-      yyjson_mut_val*   orig,
-      yyjson_mut_val*   patch,
-      yyjson_patch_err* err
+    yyjson_mut_doc*   doc,
+    yyjson_mut_val*   orig,
+    yyjson_mut_val*   patch,
+    yyjson_patch_err* err
   );
 
   /*==============================================================================
@@ -4528,11 +4284,8 @@ extern "C" {
    @warning This function is recursive and may cause a stack overflow if the
       object level is too deep.
    */
-  yyjson_api yyjson_mut_val* yyjson_mut_merge_patch(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* orig,
-      yyjson_mut_val* patch
-  );
+  yyjson_api yyjson_mut_val*
+  yyjson_mut_merge_patch(yyjson_mut_doc* doc, yyjson_mut_val* orig, yyjson_mut_val* patch);
 
   /*==============================================================================
    * JSON Structure (Implementation)
@@ -4679,9 +4432,7 @@ extern "C" {
     return (int)((yyjson_val*)val)->uni.i64;
   }
 
-  yyjson_api_inline double unsafe_yyjson_get_real(void* val) {
-    return ((yyjson_val*)val)->uni.f64;
-  }
+  yyjson_api_inline double unsafe_yyjson_get_real(void* val) { return ((yyjson_val*)val)->uni.f64; }
 
   yyjson_api_inline double unsafe_yyjson_get_num(void* val) {
     uint8_t tag = unsafe_yyjson_get_tag(val);
@@ -4713,9 +4464,7 @@ extern "C" {
     return (size_t)(((yyjson_val*)val)->tag >> YYJSON_TAG_BIT);
   }
 
-  yyjson_api_inline yyjson_val* unsafe_yyjson_get_first(yyjson_val* ctn) {
-    return ctn + 1;
-  }
+  yyjson_api_inline yyjson_val* unsafe_yyjson_get_first(yyjson_val* ctn) { return ctn + 1; }
 
   yyjson_api_inline yyjson_val* unsafe_yyjson_get_next(yyjson_val* val) {
     bool   is_ctn  = unsafe_yyjson_is_ctn(val);
@@ -4724,11 +4473,9 @@ extern "C" {
     return (yyjson_val*)(void*)((uint8_t*)val + ofs);
   }
 
-  yyjson_api_inline bool
-  unsafe_yyjson_equals_strn(void* val, const char* str, size_t len) {
+  yyjson_api_inline bool unsafe_yyjson_equals_strn(void* val, const char* str, size_t len) {
     uint64_t tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-    return ((yyjson_val*)val)->tag == tag &&
-           memcmp(((yyjson_val*)val)->uni.str, str, len) == 0;
+    return ((yyjson_val*)val)->tag == tag && memcmp(((yyjson_val*)val)->uni.str, str, len) == 0;
   }
 
   yyjson_api_inline bool unsafe_yyjson_equals_str(void* val, const char* str) {
@@ -4737,9 +4484,9 @@ extern "C" {
 
   yyjson_api_inline void
   unsafe_yyjson_set_type(void* val, yyjson_type type, yyjson_subtype subtype) {
-    uint8_t  tag     = (type | subtype);
-    uint64_t new_tag = ((yyjson_val*)val)->tag;
-    new_tag          = (new_tag & (~(uint64_t)YYJSON_TAG_MASK)) | (uint64_t)tag;
+    uint8_t  tag            = (type | subtype);
+    uint64_t new_tag        = ((yyjson_val*)val)->tag;
+    new_tag                 = (new_tag & (~(uint64_t)YYJSON_TAG_MASK)) | (uint64_t)tag;
     ((yyjson_val*)val)->tag = new_tag;
   }
 
@@ -4755,8 +4502,7 @@ extern "C" {
     ((yyjson_val*)val)->tag = tag;
   }
 
-  yyjson_api_inline void
-  unsafe_yyjson_set_raw(void* val, const char* raw, size_t len) {
+  yyjson_api_inline void unsafe_yyjson_set_raw(void* val, const char* raw, size_t len) {
     unsafe_yyjson_set_type(val, YYJSON_TYPE_RAW, YYJSON_SUBTYPE_NONE);
     unsafe_yyjson_set_len(val, len);
     ((yyjson_val*)val)->uni.str = raw;
@@ -4797,8 +4543,7 @@ extern "C" {
     ((yyjson_val*)val)->uni.str = str;
   }
 
-  yyjson_api_inline void
-  unsafe_yyjson_set_strn(void* val, const char* str, size_t len) {
+  yyjson_api_inline void unsafe_yyjson_set_strn(void* val, const char* str, size_t len) {
     unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, YYJSON_SUBTYPE_NONE);
     unsafe_yyjson_set_len(val, len);
     ((yyjson_val*)val)->uni.str = str;
@@ -4985,8 +4730,7 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_equals_strn(yyjson_val* val, const char* str, size_t len) {
+  yyjson_api_inline bool yyjson_equals_strn(yyjson_val* val, const char* str, size_t len) {
     if (yyjson_likely(val && str)) {
       return unsafe_yyjson_equals_strn(val, str, len);
     }
@@ -5001,8 +4745,7 @@ extern "C" {
     return unsafe_yyjson_equals(lhs, rhs);
   }
 
-  yyjson_api_inline bool
-  yyjson_set_raw(yyjson_val* val, const char* raw, size_t len) {
+  yyjson_api_inline bool yyjson_set_raw(yyjson_val* val, const char* raw, size_t len) {
     if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
       return false;
     unsafe_yyjson_set_raw(val, raw, len);
@@ -5060,8 +4803,7 @@ extern "C" {
     return true;
   }
 
-  yyjson_api_inline bool
-  yyjson_set_strn(yyjson_val* val, const char* str, size_t len) {
+  yyjson_api_inline bool yyjson_set_strn(yyjson_val* val, const char* str, size_t len) {
     if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
       return false;
     if (yyjson_unlikely(!str))
@@ -5122,8 +4864,7 @@ extern "C" {
    * JSON Array Iterator API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline bool
-  yyjson_arr_iter_init(yyjson_val* arr, yyjson_arr_iter* iter) {
+  yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val* arr, yyjson_arr_iter* iter) {
     if (yyjson_likely(yyjson_is_arr(arr) && iter)) {
       iter->idx = 0;
       iter->max = unsafe_yyjson_get_len(arr);
@@ -5164,13 +4905,11 @@ extern "C" {
     return yyjson_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
   }
 
-  yyjson_api_inline yyjson_val*
-  yyjson_obj_get(yyjson_val* obj, const char* key) {
+  yyjson_api_inline yyjson_val* yyjson_obj_get(yyjson_val* obj, const char* key) {
     return yyjson_obj_getn(obj, key, key ? strlen(key) : 0);
   }
 
-  yyjson_api_inline yyjson_val*
-  yyjson_obj_getn(yyjson_val* obj, const char* _key, size_t key_len) {
+  yyjson_api_inline yyjson_val* yyjson_obj_getn(yyjson_val* obj, const char* _key, size_t key_len) {
     uint64_t tag = (((uint64_t)key_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
     if (yyjson_likely(yyjson_is_obj(obj) && _key)) {
       size_t      len = unsafe_yyjson_get_len(obj);
@@ -5189,8 +4928,7 @@ extern "C" {
    * JSON Object Iterator API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline bool
-  yyjson_obj_iter_init(yyjson_val* obj, yyjson_obj_iter* iter) {
+  yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val* obj, yyjson_obj_iter* iter) {
     if (yyjson_likely(yyjson_is_obj(obj) && iter)) {
       iter->idx = 0;
       iter->max = unsafe_yyjson_get_len(obj);
@@ -5227,8 +4965,7 @@ extern "C" {
     return key ? key + 1 : NULL;
   }
 
-  yyjson_api_inline yyjson_val*
-  yyjson_obj_iter_get(yyjson_obj_iter* iter, const char* key) {
+  yyjson_api_inline yyjson_val* yyjson_obj_iter_get(yyjson_obj_iter* iter, const char* key) {
     return yyjson_obj_iter_getn(iter, key, key ? strlen(key) : 0);
   }
 
@@ -5244,8 +4981,7 @@ extern "C" {
       }
       while (idx++ < max) {
         yyjson_val* next = unsafe_yyjson_get_next(cur + 1);
-        if (unsafe_yyjson_get_len(cur) == key_len &&
-            memcmp(cur->uni.str, key, key_len) == 0) {
+        if (unsafe_yyjson_get_len(cur) == key_len && memcmp(cur->uni.str, key, key_len) == 0) {
           iter->idx = idx;
           iter->cur = next;
           return cur + 1;
@@ -5289,11 +5025,11 @@ extern "C" {
    A memory pool to hold all strings in a mutable document.
    */
   typedef struct yyjson_str_pool {
-    char*  cur;               /* cursor inside current chunk */
-    char*  end;               /* the end of current chunk */
-    size_t chunk_size;        /* chunk size in bytes while creating new chunk */
-    size_t chunk_size_max;    /* maximum chunk size in bytes */
-    yyjson_str_chunk* chunks; /* a linked list of chunks, nullable */
+    char*             cur;            /* cursor inside current chunk */
+    char*             end;            /* the end of current chunk */
+    size_t            chunk_size;     /* chunk size in bytes while creating new chunk */
+    size_t            chunk_size_max; /* maximum chunk size in bytes */
+    yyjson_str_chunk* chunks;         /* a linked list of chunks, nullable */
   } yyjson_str_pool;
 
   /**
@@ -5311,11 +5047,11 @@ extern "C" {
    A memory pool to hold all values in a mutable document.
    */
   typedef struct yyjson_val_pool {
-    yyjson_mut_val* cur;      /* cursor inside current chunk */
-    yyjson_mut_val* end;      /* the end of current chunk */
-    size_t chunk_size;        /* chunk size in bytes while creating new chunk */
-    size_t chunk_size_max;    /* maximum chunk size in bytes */
-    yyjson_val_chunk* chunks; /* a linked list of chunks, nullable */
+    yyjson_mut_val*   cur;            /* cursor inside current chunk */
+    yyjson_mut_val*   end;            /* the end of current chunk */
+    size_t            chunk_size;     /* chunk size in bytes while creating new chunk */
+    size_t            chunk_size_max; /* maximum chunk size in bytes */
+    yyjson_val_chunk* chunks;         /* a linked list of chunks, nullable */
   } yyjson_val_pool;
 
   struct yyjson_mut_doc {
@@ -5326,22 +5062,15 @@ extern "C" {
   };
 
   /* Ensures the capacity to at least equal to the specified byte length. */
-  yyjson_api bool unsafe_yyjson_str_pool_grow(
-      yyjson_str_pool*  pool,
-      const yyjson_alc* alc,
-      size_t            len
-  );
+  yyjson_api bool
+  unsafe_yyjson_str_pool_grow(yyjson_str_pool* pool, const yyjson_alc* alc, size_t len);
 
   /* Ensures the capacity to at least equal to the specified value count. */
-  yyjson_api bool unsafe_yyjson_val_pool_grow(
-      yyjson_val_pool*  pool,
-      const yyjson_alc* alc,
-      size_t            count
-  );
+  yyjson_api bool
+  unsafe_yyjson_val_pool_grow(yyjson_val_pool* pool, const yyjson_alc* alc, size_t count);
 
   /* Allocate memory for string. */
-  yyjson_api_inline char*
-  unsafe_yyjson_mut_str_alc(yyjson_mut_doc* doc, size_t len) {
+  yyjson_api_inline char* unsafe_yyjson_mut_str_alc(yyjson_mut_doc* doc, size_t len) {
     char*             mem;
     const yyjson_alc* alc  = &doc->alc;
     yyjson_str_pool*  pool = &doc->str_pool;
@@ -5365,8 +5094,7 @@ extern "C" {
     return mem;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  unsafe_yyjson_mut_val(yyjson_mut_doc* doc, size_t count) {
+  yyjson_api_inline yyjson_mut_val* unsafe_yyjson_mut_val(yyjson_mut_doc* doc, size_t count) {
     yyjson_mut_val*  val;
     yyjson_alc*      alc  = &doc->alc;
     yyjson_val_pool* pool = &doc->val_pool;
@@ -5384,13 +5112,11 @@ extern "C" {
    * Mutable JSON Document API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_get_root(yyjson_mut_doc* doc
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_get_root(yyjson_mut_doc* doc) {
     return doc ? doc->root : NULL;
   }
 
-  yyjson_api_inline void
-  yyjson_mut_doc_set_root(yyjson_mut_doc* doc, yyjson_mut_val* root) {
+  yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc* doc, yyjson_mut_val* root) {
     if (doc)
       doc->root = root;
   }
@@ -5511,28 +5237,23 @@ extern "C" {
     return yyjson_get_len((yyjson_val*)val);
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_equals_str(yyjson_mut_val* val, const char* str) {
+  yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val* val, const char* str) {
     return yyjson_equals_str((yyjson_val*)val, str);
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_equals_strn(yyjson_mut_val* val, const char* str, size_t len) {
+  yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val* val, const char* str, size_t len) {
     return yyjson_equals_strn((yyjson_val*)val, str, len);
   }
 
-  yyjson_api bool
-  unsafe_yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs);
+  yyjson_api bool unsafe_yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs);
 
-  yyjson_api_inline bool
-  yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs) {
+  yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs) {
     if (yyjson_unlikely(!lhs || !rhs))
       return false;
     return unsafe_yyjson_mut_equals(lhs, rhs);
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_set_raw(yyjson_mut_val* val, const char* raw, size_t len) {
+  yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val* val, const char* raw, size_t len) {
     if (yyjson_unlikely(!val || !raw))
       return false;
     unsafe_yyjson_set_raw(val, raw, len);
@@ -5553,8 +5274,7 @@ extern "C" {
     return true;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_set_uint(yyjson_mut_val* val, uint64_t num) {
+  yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val* val, uint64_t num) {
     if (yyjson_unlikely(!val))
       return false;
     unsafe_yyjson_set_uint(val, num);
@@ -5582,16 +5302,14 @@ extern "C" {
     return true;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_set_str(yyjson_mut_val* val, const char* str) {
+  yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val* val, const char* str) {
     if (yyjson_unlikely(!val || !str))
       return false;
     unsafe_yyjson_set_str(val, str);
     return true;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_set_strn(yyjson_mut_val* val, const char* str, size_t len) {
+  yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val* val, const char* str, size_t len) {
     if (yyjson_unlikely(!val || !str))
       return false;
     unsafe_yyjson_set_strn(val, str, len);
@@ -5616,8 +5334,7 @@ extern "C" {
    * Mutable JSON Value Creation API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_raw(yyjson_mut_doc* doc, const char* str) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_raw(yyjson_mut_doc* doc, const char* str) {
     if (yyjson_likely(str))
       return yyjson_mut_rawn(doc, str, strlen(str));
     return NULL;
@@ -5636,8 +5353,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_rawcpy(yyjson_mut_doc* doc, const char* str) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_rawcpy(yyjson_mut_doc* doc, const char* str) {
     if (yyjson_likely(str))
       return yyjson_mut_rawncpy(doc, str, strlen(str));
     return NULL;
@@ -5690,8 +5406,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_bool(yyjson_mut_doc* doc, bool _val) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_bool(yyjson_mut_doc* doc, bool _val) {
     if (yyjson_likely(doc)) {
       yyjson_mut_val* val = unsafe_yyjson_mut_val(doc, 1);
       if (yyjson_likely(val)) {
@@ -5702,8 +5417,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_uint(yyjson_mut_doc* doc, uint64_t num) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_uint(yyjson_mut_doc* doc, uint64_t num) {
     if (yyjson_likely(doc)) {
       yyjson_mut_val* val = unsafe_yyjson_mut_val(doc, 1);
       if (yyjson_likely(val)) {
@@ -5715,8 +5429,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_sint(yyjson_mut_doc* doc, int64_t num) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_sint(yyjson_mut_doc* doc, int64_t num) {
     if (yyjson_likely(doc)) {
       yyjson_mut_val* val = unsafe_yyjson_mut_val(doc, 1);
       if (yyjson_likely(val)) {
@@ -5728,13 +5441,11 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_int(yyjson_mut_doc* doc, int64_t num) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_int(yyjson_mut_doc* doc, int64_t num) {
     return yyjson_mut_sint(doc, num);
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_real(yyjson_mut_doc* doc, double num) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_real(yyjson_mut_doc* doc, double num) {
     if (yyjson_likely(doc)) {
       yyjson_mut_val* val = unsafe_yyjson_mut_val(doc, 1);
       if (yyjson_likely(val)) {
@@ -5746,8 +5457,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_str(yyjson_mut_doc* doc, const char* str) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_str(yyjson_mut_doc* doc, const char* str) {
     if (yyjson_likely(str))
       return yyjson_mut_strn(doc, str, strlen(str));
     return NULL;
@@ -5766,8 +5476,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_strcpy(yyjson_mut_doc* doc, const char* str) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_strcpy(yyjson_mut_doc* doc, const char* str) {
     if (yyjson_likely(str))
       return yyjson_mut_strncpy(doc, str, strlen(str));
     return NULL;
@@ -5795,8 +5504,7 @@ extern "C" {
     return yyjson_mut_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_arr_get(yyjson_mut_val* arr, size_t idx) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get(yyjson_mut_val* arr, size_t idx) {
     if (yyjson_likely(idx < yyjson_mut_arr_size(arr))) {
       yyjson_mut_val* val = (yyjson_mut_val*)arr->uni.ptr;
       while (idx-- > 0) val = val->next;
@@ -5805,16 +5513,14 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_first(yyjson_mut_val* arr
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_first(yyjson_mut_val* arr) {
     if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
       return ((yyjson_mut_val*)arr->uni.ptr)->next;
     }
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_last(yyjson_mut_val* arr
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_get_last(yyjson_mut_val* arr) {
     if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
       return ((yyjson_mut_val*)arr->uni.ptr);
     }
@@ -5825,8 +5531,7 @@ extern "C" {
    * Mutable JSON Array Iterator API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_iter_init(yyjson_mut_val* arr, yyjson_mut_arr_iter* iter) {
+  yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val* arr, yyjson_mut_arr_iter* iter) {
     if (yyjson_likely(yyjson_mut_is_arr(arr) && iter)) {
       iter->idx = 0;
       iter->max = unsafe_yyjson_get_len(arr);
@@ -5840,21 +5545,17 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline yyjson_mut_arr_iter
-  yyjson_mut_arr_iter_with(yyjson_mut_val* arr) {
+  yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with(yyjson_mut_val* arr) {
     yyjson_mut_arr_iter iter;
     yyjson_mut_arr_iter_init(arr, &iter);
     return iter;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter* iter
-  ) {
+  yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter* iter) {
     return iter ? iter->idx < iter->max : false;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_next(
-      yyjson_mut_arr_iter* iter
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_next(yyjson_mut_arr_iter* iter) {
     if (iter && iter->idx < iter->max) {
       yyjson_mut_val* val = iter->cur;
       iter->pre           = val;
@@ -5865,9 +5566,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_remove(
-      yyjson_mut_arr_iter* iter
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_iter_remove(yyjson_mut_arr_iter* iter) {
     if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
       yyjson_mut_val* prev = iter->pre;
       yyjson_mut_val* cur  = iter->cur;
@@ -5899,178 +5598,130 @@ extern "C" {
     return NULL;
   }
 
-#define yyjson_mut_arr_with_func(func)                                       \
-  if (yyjson_likely(                                                         \
-          doc && ((0 < count &&                                              \
-                   count < (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || \
-                  count == 0)                                                \
-      )) {                                                                   \
-    yyjson_mut_val* arr = unsafe_yyjson_mut_val(doc, 1 + count);             \
-    if (yyjson_likely(arr)) {                                                \
-      arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR;      \
-      if (count > 0) {                                                       \
-        size_t i;                                                            \
-        for (i = 0; i < count; i++) {                                        \
-          yyjson_mut_val* val       = arr + i + 1;                           \
-          func            val->next = val + 1;                               \
-        }                                                                    \
-        arr[count].next = arr + 1;                                           \
-        arr->uni.ptr    = arr + count;                                       \
-      }                                                                      \
-      return arr;                                                            \
-    }                                                                        \
-  }                                                                          \
+#define yyjson_mut_arr_with_func(func)                                                       \
+  if (yyjson_likely(                                                                         \
+        doc &&                                                                               \
+        ((0 < count && count < (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || count == 0) \
+      )) {                                                                                   \
+    yyjson_mut_val* arr = unsafe_yyjson_mut_val(doc, 1 + count);                             \
+    if (yyjson_likely(arr)) {                                                                \
+      arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR;                      \
+      if (count > 0) {                                                                       \
+        size_t i;                                                                            \
+        for (i = 0; i < count; i++) {                                                        \
+          yyjson_mut_val* val       = arr + i + 1;                                           \
+          func            val->next = val + 1;                                               \
+        }                                                                                    \
+        arr[count].next = arr + 1;                                                           \
+        arr->uni.ptr    = arr + count;                                                       \
+      }                                                                                      \
+      return arr;                                                                            \
+    }                                                                                        \
+  }                                                                                          \
   return NULL
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_bool(
-      yyjson_mut_doc* doc,
-      const bool*     vals,
-      size_t          count
-  ) {
-    yyjson_mut_arr_with_func({
-      val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3);
-    });
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_bool(yyjson_mut_doc* doc, const bool* vals, size_t count) {
+    yyjson_mut_arr_with_func({ val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3); });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint(
-      yyjson_mut_doc* doc,
-      const int64_t*  vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint(yyjson_mut_doc* doc, const int64_t* vals, size_t count) {
     return yyjson_mut_arr_with_sint64(doc, vals, count);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint(
-      yyjson_mut_doc* doc,
-      const uint64_t* vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint(yyjson_mut_doc* doc, const uint64_t* vals, size_t count) {
     return yyjson_mut_arr_with_uint64(doc, vals, count);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_real(
-      yyjson_mut_doc* doc,
-      const double*   vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_real(yyjson_mut_doc* doc, const double* vals, size_t count) {
     return yyjson_mut_arr_with_double(doc, vals, count);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint8(
-      yyjson_mut_doc* doc,
-      const int8_t*   vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint8(yyjson_mut_doc* doc, const int8_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
       val->uni.i64 = (int64_t)vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint16(
-      yyjson_mut_doc* doc,
-      const int16_t*  vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint16(yyjson_mut_doc* doc, const int16_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
       val->uni.i64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint32(
-      yyjson_mut_doc* doc,
-      const int32_t*  vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint32(yyjson_mut_doc* doc, const int32_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
       val->uni.i64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_sint64(
-      yyjson_mut_doc* doc,
-      const int64_t*  vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_sint64(yyjson_mut_doc* doc, const int64_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
       val->uni.i64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint8(
-      yyjson_mut_doc* doc,
-      const uint8_t*  vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint8(yyjson_mut_doc* doc, const uint8_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
       val->uni.u64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint16(
-      yyjson_mut_doc* doc,
-      const uint16_t* vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint16(yyjson_mut_doc* doc, const uint16_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
       val->uni.u64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint32(
-      yyjson_mut_doc* doc,
-      const uint32_t* vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint32(yyjson_mut_doc* doc, const uint32_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
       val->uni.u64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_uint64(
-      yyjson_mut_doc* doc,
-      const uint64_t* vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_uint64(yyjson_mut_doc* doc, const uint64_t* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
       val->uni.u64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_float(
-      yyjson_mut_doc* doc,
-      const float*    vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_float(yyjson_mut_doc* doc, const float* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
       val->uni.f64 = (double)vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_double(
-      yyjson_mut_doc* doc,
-      const double*   vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_double(yyjson_mut_doc* doc, const double* vals, size_t count) {
     yyjson_mut_arr_with_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
       val->uni.f64 = vals[i];
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_str(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_str(yyjson_mut_doc* doc, const char** vals, size_t count) {
     yyjson_mut_arr_with_func({
       uint64_t len = (uint64_t)strlen(vals[i]);
       val->tag     = (len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
@@ -6081,10 +5732,10 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_strn(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      const size_t*   lens,
-      size_t          count
+    yyjson_mut_doc* doc,
+    const char**    vals,
+    const size_t*   lens,
+    size_t          count
   ) {
     if (yyjson_unlikely(count > 0 && !lens))
       return NULL;
@@ -6096,11 +5747,8 @@ extern "C" {
     });
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_strcpy(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_arr_with_strcpy(yyjson_mut_doc* doc, const char** vals, size_t count) {
     size_t      len;
     const char* str;
     yyjson_mut_arr_with_func({
@@ -6116,10 +5764,10 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_with_strncpy(
-      yyjson_mut_doc* doc,
-      const char**    vals,
-      const size_t*   lens,
-      size_t          count
+    yyjson_mut_doc* doc,
+    const char**    vals,
+    const size_t*   lens,
+    size_t          count
   ) {
     size_t      len;
     const char* str;
@@ -6172,8 +5820,7 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_append(yyjson_mut_val* arr, yyjson_mut_val* val) {
+  yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val* arr, yyjson_mut_val* val) {
     if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
       size_t len = unsafe_yyjson_get_len(arr);
       unsafe_yyjson_set_len(arr, len + 1);
@@ -6191,8 +5838,7 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_prepend(yyjson_mut_val* arr, yyjson_mut_val* val) {
+  yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val* arr, yyjson_mut_val* val) {
     if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
       size_t len = unsafe_yyjson_get_len(arr);
       unsafe_yyjson_set_len(arr, len + 1);
@@ -6238,8 +5884,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_arr_remove(yyjson_mut_val* arr, size_t idx) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove(yyjson_mut_val* arr, size_t idx) {
     if (yyjson_likely(yyjson_mut_is_arr(arr))) {
       size_t len = unsafe_yyjson_get_len(arr);
       if (yyjson_likely(idx < len)) {
@@ -6263,9 +5908,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_first(
-      yyjson_mut_val* arr
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_first(yyjson_mut_val* arr) {
     if (yyjson_likely(yyjson_mut_is_arr(arr))) {
       size_t len = unsafe_yyjson_get_len(arr);
       if (len > 1) {
@@ -6283,9 +5926,7 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_last(
-      yyjson_mut_val* arr
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_arr_remove_last(yyjson_mut_val* arr) {
     if (yyjson_likely(yyjson_mut_is_arr(arr))) {
       size_t len = unsafe_yyjson_get_len(arr);
       if (yyjson_likely(len > 1)) {
@@ -6340,11 +5981,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_rotate(yyjson_mut_val* arr, size_t idx) {
-    if (yyjson_likely(
-            yyjson_mut_is_arr(arr) && unsafe_yyjson_get_len(arr) > idx
-        )) {
+  yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val* arr, size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) && unsafe_yyjson_get_len(arr) > idx)) {
       yyjson_mut_val* val = (yyjson_mut_val*)arr->uni.ptr;
       while (idx-- > 0) val = val->next;
       arr->uni.ptr = (void*)val;
@@ -6357,13 +5995,11 @@ extern "C" {
    * Mutable JSON Array Modification Convenience API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_val(yyjson_mut_val* arr, yyjson_mut_val* val) {
+  yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val* arr, yyjson_mut_val* val) {
     return yyjson_mut_arr_append(arr, val);
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_null(yyjson_mut_doc* doc, yyjson_mut_val* arr) {
+  yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc* doc, yyjson_mut_val* arr) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_null(doc);
       return yyjson_mut_arr_append(arr, val);
@@ -6371,8 +6007,7 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_true(yyjson_mut_doc* doc, yyjson_mut_val* arr) {
+  yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc* doc, yyjson_mut_val* arr) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_true(doc);
       return yyjson_mut_arr_append(arr, val);
@@ -6380,8 +6015,7 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_arr_add_false(yyjson_mut_doc* doc, yyjson_mut_val* arr) {
+  yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc* doc, yyjson_mut_val* arr) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_false(doc);
       return yyjson_mut_arr_append(arr, val);
@@ -6398,11 +6032,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_uint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      uint64_t        num
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_uint(yyjson_mut_doc* doc, yyjson_mut_val* arr, uint64_t num) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_uint(doc, num);
       return yyjson_mut_arr_append(arr, val);
@@ -6410,11 +6041,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_sint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      int64_t         num
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_sint(yyjson_mut_doc* doc, yyjson_mut_val* arr, int64_t num) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_sint(doc, num);
       return yyjson_mut_arr_append(arr, val);
@@ -6422,11 +6050,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_int(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      int64_t         num
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_int(yyjson_mut_doc* doc, yyjson_mut_val* arr, int64_t num) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_sint(doc, num);
       return yyjson_mut_arr_append(arr, val);
@@ -6434,11 +6059,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_real(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      double          num
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_real(yyjson_mut_doc* doc, yyjson_mut_val* arr, double num) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_real(doc, num);
       return yyjson_mut_arr_append(arr, val);
@@ -6446,11 +6068,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_str(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_str(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_str(doc, str);
       return yyjson_mut_arr_append(arr, val);
@@ -6458,12 +6077,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_strn(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str,
-      size_t          len
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_strn(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str, size_t len) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_strn(doc, str, len);
       return yyjson_mut_arr_append(arr, val);
@@ -6471,11 +6086,8 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_arr_add_strcpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_arr_add_strcpy(yyjson_mut_doc* doc, yyjson_mut_val* arr, const char* str) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_strcpy(doc, str);
       return yyjson_mut_arr_append(arr, val);
@@ -6484,10 +6096,10 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_arr_add_strncpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* arr,
-      const char*     str,
-      size_t          len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* arr,
+    const char*     str,
+    size_t          len
   ) {
     if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
       yyjson_mut_val* val = yyjson_mut_strncpy(doc, str, len);
@@ -6522,8 +6134,7 @@ extern "C" {
     return yyjson_mut_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_obj_get(yyjson_mut_val* obj, const char* key) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_get(yyjson_mut_val* obj, const char* key) {
     return yyjson_mut_obj_getn(obj, key, key ? strlen(key) : 0);
   }
 
@@ -6547,8 +6158,7 @@ extern "C" {
    * Mutable JSON Object Iterator API (Implementation)
    *============================================================================*/
 
-  yyjson_api_inline bool
-  yyjson_mut_obj_iter_init(yyjson_mut_val* obj, yyjson_mut_obj_iter* iter) {
+  yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val* obj, yyjson_mut_obj_iter* iter) {
     if (yyjson_likely(yyjson_mut_is_obj(obj) && iter)) {
       iter->idx = 0;
       iter->max = unsafe_yyjson_get_len(obj);
@@ -6562,21 +6172,17 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline yyjson_mut_obj_iter
-  yyjson_mut_obj_iter_with(yyjson_mut_val* obj) {
+  yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with(yyjson_mut_val* obj) {
     yyjson_mut_obj_iter iter;
     yyjson_mut_obj_iter_init(obj, &iter);
     return iter;
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter* iter
-  ) {
+  yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter* iter) {
     return iter ? iter->idx < iter->max : false;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_next(
-      yyjson_mut_obj_iter* iter
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_next(yyjson_mut_obj_iter* iter) {
     if (iter && iter->idx < iter->max) {
       yyjson_mut_val* key = iter->cur;
       iter->pre           = key;
@@ -6587,15 +6193,11 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_get_val(
-      yyjson_mut_val* key
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_get_val(yyjson_mut_val* key) {
     return key ? key->next : NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_remove(
-      yyjson_mut_obj_iter* iter
-  ) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_remove(yyjson_mut_obj_iter* iter) {
     if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
       yyjson_mut_val* prev = iter->pre;
       yyjson_mut_val* cur  = iter->cur;
@@ -6617,11 +6219,8 @@ extern "C" {
     return yyjson_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_iter_getn(
-      yyjson_mut_obj_iter* iter,
-      const char*          key,
-      size_t               key_len
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_iter_getn(yyjson_mut_obj_iter* iter, const char* key, size_t key_len) {
     if (iter && key) {
       size_t          idx = 0;
       size_t          max = iter->max;
@@ -6629,8 +6228,7 @@ extern "C" {
       while (idx++ < max) {
         pre = cur;
         cur = cur->next->next;
-        if (unsafe_yyjson_get_len(cur) == key_len &&
-            memcmp(cur->uni.str, key, key_len) == 0) {
+        if (unsafe_yyjson_get_len(cur) == key_len && memcmp(cur->uni.str, key, key_len) == 0) {
           iter->idx += idx;
           if (iter->idx > max)
             iter->idx -= max + 1;
@@ -6658,12 +6256,8 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_with_str(
-      yyjson_mut_doc* doc,
-      const char**    keys,
-      const char**    vals,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_with_str(yyjson_mut_doc* doc, const char** keys, const char** vals, size_t count) {
     if (yyjson_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) {
       yyjson_mut_val* obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
       if (yyjson_likely(obj)) {
@@ -6675,12 +6269,12 @@ extern "C" {
             yyjson_mut_val* val     = obj + (i * 2 + 2);
             uint64_t        key_len = (uint64_t)strlen(keys[i]);
             uint64_t        val_len = (uint64_t)strlen(vals[i]);
-            key->tag     = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            val->tag     = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            key->uni.str = keys[i];
-            val->uni.str = vals[i];
-            key->next    = val;
-            val->next    = val + 1;
+            key->tag                = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+            val->tag                = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+            key->uni.str            = keys[i];
+            val->uni.str            = vals[i];
+            key->next               = val;
+            val->next               = val + 1;
           }
           obj[count * 2].next = obj + 1;
           obj->uni.ptr        = obj + (count * 2 - 1);
@@ -6691,11 +6285,8 @@ extern "C" {
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_with_kv(
-      yyjson_mut_doc* doc,
-      const char**    pairs,
-      size_t          count
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_with_kv(yyjson_mut_doc* doc, const char** pairs, size_t count) {
     if (yyjson_likely(doc && ((count > 0 && pairs) || (count == 0)))) {
       yyjson_mut_val* obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
       if (yyjson_likely(obj)) {
@@ -6709,12 +6300,12 @@ extern "C" {
             const char*     val_str = pairs[i * 2 + 1];
             uint64_t        key_len = (uint64_t)strlen(key_str);
             uint64_t        val_len = (uint64_t)strlen(val_str);
-            key->tag     = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            val->tag     = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
-            key->uni.str = key_str;
-            val->uni.str = val_str;
-            key->next    = val;
-            val->next    = val + 1;
+            key->tag                = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+            val->tag                = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+            key->uni.str            = key_str;
+            val->uni.str            = val_str;
+            key->next               = val;
+            val->next               = val + 1;
           }
           obj[count * 2].next = obj + 1;
           obj->uni.ptr        = obj + (count * 2 - 1);
@@ -6730,10 +6321,10 @@ extern "C" {
    *============================================================================*/
 
   yyjson_api_inline void unsafe_yyjson_mut_obj_add(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val,
-      size_t          len
+    yyjson_mut_val* obj,
+    yyjson_mut_val* key,
+    yyjson_mut_val* val,
+    size_t          len
   ) {
     if (yyjson_likely(len)) {
       yyjson_mut_val* prev_val = ((yyjson_mut_val*)obj->uni.ptr)->next;
@@ -6749,10 +6340,10 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* unsafe_yyjson_mut_obj_remove(
-      yyjson_mut_val* obj,
-      const char*     key,
-      size_t          key_len,
-      uint64_t        key_tag
+    yyjson_mut_val* obj,
+    const char*     key,
+    size_t          key_len,
+    uint64_t        key_tag
   ) {
     size_t obj_len = unsafe_yyjson_get_len(obj);
     if (obj_len) {
@@ -6761,8 +6352,7 @@ extern "C" {
       yyjson_mut_val* removed_item = NULL;
       size_t          i;
       for (i = 0; i < obj_len; i++) {
-        if (key_tag == cur_key->tag &&
-            memcmp(key, cur_key->uni.ptr, key_len) == 0) {
+        if (key_tag == cur_key->tag && memcmp(key, cur_key->uni.ptr, key_len) == 0) {
           if (!removed_item)
             removed_item = cur_key->next;
           cur_key             = cur_key->next->next;
@@ -6783,11 +6373,8 @@ extern "C" {
     }
   }
 
-  yyjson_api_inline bool unsafe_yyjson_mut_obj_replace(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  ) {
+  yyjson_api_inline bool
+  unsafe_yyjson_mut_obj_replace(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val) {
     size_t key_len = unsafe_yyjson_get_len(key);
     size_t obj_len = unsafe_yyjson_get_len(obj);
     if (obj_len) {
@@ -6795,8 +6382,7 @@ extern "C" {
       yyjson_mut_val* cur_key = pre_key->next->next;
       size_t          i;
       for (i = 0; i < obj_len; i++) {
-        if (key->tag == cur_key->tag &&
-            memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
+        if (key->tag == cur_key->tag && memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
           cur_key->next->tag     = val->tag;
           cur_key->next->uni.u64 = val->uni.u64;
           return true;
@@ -6808,32 +6394,23 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline void
-  unsafe_yyjson_mut_obj_rotate(yyjson_mut_val* obj, size_t idx) {
+  yyjson_api_inline void unsafe_yyjson_mut_obj_rotate(yyjson_mut_val* obj, size_t idx) {
     yyjson_mut_val* key = (yyjson_mut_val*)obj->uni.ptr;
     while (idx-- > 0) key = key->next->next;
     obj->uni.ptr = (void*)key;
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_add(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  ) {
-    if (yyjson_likely(
-            yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key) && val
-        )) {
+  yyjson_api_inline bool
+  yyjson_mut_obj_add(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key) && val)) {
       unsafe_yyjson_mut_obj_add(obj, key, val, unsafe_yyjson_get_len(obj));
       return true;
     }
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_put(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_obj_put(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val) {
     bool                replaced = false;
     size_t              key_len;
     yyjson_mut_obj_iter iter;
@@ -6843,8 +6420,7 @@ extern "C" {
     key_len = unsafe_yyjson_get_len(key);
     yyjson_mut_obj_iter_init(obj, &iter);
     while ((cur_key = yyjson_mut_obj_iter_next(&iter))) {
-      if (key->tag == cur_key->tag &&
-          memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
+      if (key->tag == cur_key->tag && memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
         if (!replaced && val) {
           replaced      = true;
           val->next     = cur_key->next->next;
@@ -6859,15 +6435,9 @@ extern "C" {
     return true;
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_insert(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val,
-      size_t          idx
-  ) {
-    if (yyjson_likely(
-            yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key) && val
-        )) {
+  yyjson_api_inline bool
+  yyjson_mut_obj_insert(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val, size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key) && val)) {
       size_t len = unsafe_yyjson_get_len(obj);
       if (yyjson_likely(len >= idx)) {
         if (len > idx) {
@@ -6887,9 +6457,7 @@ extern "C" {
   yyjson_api_inline yyjson_mut_val*
   yyjson_mut_obj_remove(yyjson_mut_val* obj, yyjson_mut_val* key) {
     if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key))) {
-      return unsafe_yyjson_mut_obj_remove(
-          obj, key->uni.str, unsafe_yyjson_get_len(key), key->tag
-      );
+      return unsafe_yyjson_mut_obj_remove(obj, key->uni.str, unsafe_yyjson_get_len(key), key->tag);
     }
     return NULL;
   }
@@ -6898,17 +6466,14 @@ extern "C" {
   yyjson_mut_obj_remove_key(yyjson_mut_val* obj, const char* key) {
     if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
       size_t   key_len = strlen(key);
-      uint64_t tag = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+      uint64_t tag     = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
       return unsafe_yyjson_mut_obj_remove(obj, key, key_len, tag);
     }
     return NULL;
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_remove_keyn(
-      yyjson_mut_val* obj,
-      const char*     key,
-      size_t          key_len
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_remove_keyn(yyjson_mut_val* obj, const char* key, size_t key_len) {
     if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
       uint64_t tag = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
       return unsafe_yyjson_mut_obj_remove(obj, key, key_len, tag);
@@ -6924,24 +6489,16 @@ extern "C" {
     return false;
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_replace(
-      yyjson_mut_val* obj,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  ) {
-    if (yyjson_likely(
-            yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key) && val
-        )) {
+  yyjson_api_inline bool
+  yyjson_mut_obj_replace(yyjson_mut_val* obj, yyjson_mut_val* key, yyjson_mut_val* val) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key) && val)) {
       return unsafe_yyjson_mut_obj_replace(obj, key, val);
     }
     return false;
   }
 
-  yyjson_api_inline bool
-  yyjson_mut_obj_rotate(yyjson_mut_val* obj, size_t idx) {
-    if (yyjson_likely(
-            yyjson_mut_is_obj(obj) && unsafe_yyjson_get_len(obj) > idx
-        )) {
+  yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val* obj, size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && unsafe_yyjson_get_len(obj) > idx)) {
       unsafe_yyjson_mut_obj_rotate(obj, idx);
       return true;
     }
@@ -6967,52 +6524,31 @@ extern "C" {
   }                                                                \
   return false
 
-  yyjson_api_inline bool yyjson_mut_obj_add_null(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key
-  ) {
-    yyjson_mut_obj_add_func({
-      val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
-    });
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_null(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* _key) {
+    yyjson_mut_obj_add_func({ val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE; });
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_add_true(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key
-  ) {
-    yyjson_mut_obj_add_func({
-      val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
-    });
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_true(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* _key) {
+    yyjson_mut_obj_add_func({ val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE; });
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_add_false(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key
-  ) {
-    yyjson_mut_obj_add_func({
-      val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
-    });
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_false(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* _key) {
+    yyjson_mut_obj_add_func({ val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE; });
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_add_bool(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      bool            _val
-  ) {
-    yyjson_mut_obj_add_func({
-      val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3);
-    });
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_bool(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* _key, bool _val) {
+    yyjson_mut_obj_add_func({ val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3); });
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_uint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      uint64_t        _val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    uint64_t        _val
   ) {
     yyjson_mut_obj_add_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
@@ -7021,10 +6557,10 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_sint(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      int64_t         _val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    int64_t         _val
   ) {
     yyjson_mut_obj_add_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
@@ -7032,24 +6568,16 @@ extern "C" {
     });
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_add_int(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      int64_t         _val
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_int(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* _key, int64_t _val) {
     yyjson_mut_obj_add_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
       val->uni.i64 = _val;
     });
   }
 
-  yyjson_api_inline bool yyjson_mut_obj_add_real(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      double          _val
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_obj_add_real(yyjson_mut_doc* doc, yyjson_mut_val* obj, const char* _key, double _val) {
     yyjson_mut_obj_add_func({
       val->tag     = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
       val->uni.f64 = _val;
@@ -7057,25 +6585,25 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_str(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      const char*     _val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    const char*     _val
   ) {
     if (yyjson_unlikely(!_val))
       return false;
     yyjson_mut_obj_add_func({
-      val->tag = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+      val->tag     = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
       val->uni.str = _val;
     });
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_strn(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      const char*     _val,
-      size_t          _len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    const char*     _val,
+    size_t          _len
   ) {
     if (yyjson_unlikely(!_val))
       return false;
@@ -7086,10 +6614,10 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_strcpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      const char*     _val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    const char*     _val
   ) {
     if (yyjson_unlikely(!_val))
       return false;
@@ -7103,11 +6631,11 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_strncpy(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      const char*     _val,
-      size_t          _len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    const char*     _val,
+    size_t          _len
   ) {
     if (yyjson_unlikely(!_val))
       return false;
@@ -7120,10 +6648,10 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_obj_add_val(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     _key,
-      yyjson_mut_val* _val
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     _key,
+    yyjson_mut_val* _val
   ) {
     if (yyjson_unlikely(!_val))
       return false;
@@ -7135,19 +6663,15 @@ extern "C" {
     return yyjson_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_obj_remove_strn(
-      yyjson_mut_val* obj,
-      const char*     _key,
-      size_t          _len
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_obj_remove_strn(yyjson_mut_val* obj, const char* _key, size_t _len) {
     if (yyjson_likely(yyjson_mut_is_obj(obj) && _key)) {
       yyjson_mut_val*     key;
       yyjson_mut_obj_iter iter;
       yyjson_mut_val*     val_removed = NULL;
       yyjson_mut_obj_iter_init(obj, &iter);
       while ((key = yyjson_mut_obj_iter_next(&iter)) != NULL) {
-        if (unsafe_yyjson_get_len(key) == _len &&
-            memcmp(key->uni.str, _key, _len) == 0) {
+        if (unsafe_yyjson_get_len(key) == _len && memcmp(key->uni.str, _key, _len) == 0) {
           if (!val_removed)
             val_removed = key->next;
           yyjson_mut_obj_iter_remove(&iter);
@@ -7159,25 +6683,23 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_obj_rename_key(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      const char*     new_key
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    const char*     new_key
   ) {
     if (!key || !new_key)
       return false;
-    return yyjson_mut_obj_rename_keyn(
-        doc, obj, key, strlen(key), new_key, strlen(new_key)
-    );
+    return yyjson_mut_obj_rename_keyn(doc, obj, key, strlen(key), new_key, strlen(new_key));
   }
 
   yyjson_api_inline bool yyjson_mut_obj_rename_keyn(
-      yyjson_mut_doc* doc,
-      yyjson_mut_val* obj,
-      const char*     key,
-      size_t          len,
-      const char*     new_key,
-      size_t          new_len
+    yyjson_mut_doc* doc,
+    yyjson_mut_val* obj,
+    const char*     key,
+    size_t          len,
+    const char*     new_key,
+    size_t          new_len
   ) {
     char*               cpy_key = NULL;
     yyjson_mut_val*     old_key;
@@ -7212,72 +6734,62 @@ extern "C" {
   } while (false)
 
   /* require: val != NULL, *ptr == '/', len > 0 */
-  yyjson_api yyjson_val* unsafe_yyjson_ptr_getx(
-      yyjson_val*     val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_err* err
-  );
+  yyjson_api yyjson_val*
+  unsafe_yyjson_ptr_getx(yyjson_val* val, const char* ptr, size_t len, yyjson_ptr_err* err);
 
   /* require: val != NULL, *ptr == '/', len > 0 */
   yyjson_api yyjson_mut_val* unsafe_yyjson_mut_ptr_getx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /* require: val/new_val/doc != NULL, *ptr == '/', len > 0 */
   yyjson_api bool unsafe_yyjson_mut_ptr_putx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc,
-      bool            create_parent,
-      bool            insert_new,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc,
+    bool            create_parent,
+    bool            insert_new,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /* require: val/err != NULL, *ptr == '/', len > 0 */
   yyjson_api yyjson_mut_val* unsafe_yyjson_mut_ptr_replacex(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
   /* require: val/err != NULL, *ptr == '/', len > 0 */
   yyjson_api yyjson_mut_val* unsafe_yyjson_mut_ptr_removex(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   );
 
-  yyjson_api_inline yyjson_val*
-  yyjson_doc_ptr_get(yyjson_doc* doc, const char* ptr) {
+  yyjson_api_inline yyjson_val* yyjson_doc_ptr_get(yyjson_doc* doc, const char* ptr) {
     if (yyjson_unlikely(!ptr))
       return NULL;
     return yyjson_doc_ptr_getn(doc, ptr, strlen(ptr));
   }
 
-  yyjson_api_inline yyjson_val*
-  yyjson_doc_ptr_getn(yyjson_doc* doc, const char* ptr, size_t len) {
+  yyjson_api_inline yyjson_val* yyjson_doc_ptr_getn(yyjson_doc* doc, const char* ptr, size_t len) {
     return yyjson_doc_ptr_getx(doc, ptr, len, NULL);
   }
 
-  yyjson_api_inline yyjson_val* yyjson_doc_ptr_getx(
-      yyjson_doc*     doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_err* err
-  ) {
+  yyjson_api_inline yyjson_val*
+  yyjson_doc_ptr_getx(yyjson_doc* doc, const char* ptr, size_t len, yyjson_ptr_err* err) {
     yyjson_ptr_set_err(NONE, NULL);
     if (yyjson_unlikely(!doc || !ptr)) {
       yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@@ -7297,24 +6809,18 @@ extern "C" {
     return unsafe_yyjson_ptr_getx(doc->root, ptr, len, err);
   }
 
-  yyjson_api_inline yyjson_val*
-  yyjson_ptr_get(yyjson_val* val, const char* ptr) {
+  yyjson_api_inline yyjson_val* yyjson_ptr_get(yyjson_val* val, const char* ptr) {
     if (yyjson_unlikely(!ptr))
       return NULL;
     return yyjson_ptr_getn(val, ptr, strlen(ptr));
   }
 
-  yyjson_api_inline yyjson_val*
-  yyjson_ptr_getn(yyjson_val* val, const char* ptr, size_t len) {
+  yyjson_api_inline yyjson_val* yyjson_ptr_getn(yyjson_val* val, const char* ptr, size_t len) {
     return yyjson_ptr_getx(val, ptr, len, NULL);
   }
 
-  yyjson_api_inline yyjson_val* yyjson_ptr_getx(
-      yyjson_val*     val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_err* err
-  ) {
+  yyjson_api_inline yyjson_val*
+  yyjson_ptr_getx(yyjson_val* val, const char* ptr, size_t len, yyjson_ptr_err* err) {
     yyjson_ptr_set_err(NONE, NULL);
     if (yyjson_unlikely(!val || !ptr)) {
       yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@@ -7330,8 +6836,7 @@ extern "C" {
     return unsafe_yyjson_ptr_getx(val, ptr, len, err);
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_doc_ptr_get(yyjson_mut_doc* doc, const char* ptr) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_get(yyjson_mut_doc* doc, const char* ptr) {
     if (!ptr)
       return NULL;
     return yyjson_mut_doc_ptr_getn(doc, ptr, strlen(ptr));
@@ -7343,11 +6848,11 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_getx(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7371,8 +6876,7 @@ extern "C" {
     return unsafe_yyjson_mut_ptr_getx(doc->root, ptr, len, ctx, err);
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_ptr_get(yyjson_mut_val* val, const char* ptr) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_get(yyjson_mut_val* val, const char* ptr) {
     if (!ptr)
       return NULL;
     return yyjson_mut_ptr_getn(val, ptr, strlen(ptr));
@@ -7384,11 +6888,11 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_getx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7408,33 +6912,30 @@ extern "C" {
     return unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err);
   }
 
-  yyjson_api_inline bool yyjson_mut_doc_ptr_add(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_doc_ptr_add(yyjson_mut_doc* doc, const char* ptr, yyjson_mut_val* new_val) {
     if (yyjson_unlikely(!ptr))
       return false;
     return yyjson_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val);
   }
 
   yyjson_api_inline bool yyjson_mut_doc_ptr_addn(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   ) {
     return yyjson_mut_doc_ptr_addx(doc, ptr, len, new_val, true, NULL, NULL);
   }
 
   yyjson_api_inline bool yyjson_mut_doc_ptr_addx(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7467,24 +6968,22 @@ extern "C" {
         yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
         return false;
       }
-      if (unsafe_yyjson_mut_ptr_putx(
-              root, ptr, len, new_val, doc, create_parent, true, ctx, err
-          )) {
+      if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc, create_parent, true, ctx, err)) {
         doc->root = root;
         return true;
       }
       return false;
     }
     return unsafe_yyjson_mut_ptr_putx(
-        doc->root, ptr, len, new_val, doc, create_parent, true, ctx, err
+      doc->root, ptr, len, new_val, doc, create_parent, true, ctx, err
     );
   }
 
   yyjson_api_inline bool yyjson_mut_ptr_add(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   ) {
     if (yyjson_unlikely(!ptr))
       return false;
@@ -7492,24 +6991,24 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_ptr_addn(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   ) {
     return yyjson_mut_ptr_addx(val, ptr, len, new_val, doc, true, NULL, NULL);
   }
 
   yyjson_api_inline bool yyjson_mut_ptr_addx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7527,38 +7026,33 @@ extern "C" {
       yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
       return false;
     }
-    return unsafe_yyjson_mut_ptr_putx(
-        val, ptr, len, new_val, doc, create_parent, true, ctx, err
-    );
+    return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val, doc, create_parent, true, ctx, err);
   }
 
-  yyjson_api_inline bool yyjson_mut_doc_ptr_set(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  ) {
+  yyjson_api_inline bool
+  yyjson_mut_doc_ptr_set(yyjson_mut_doc* doc, const char* ptr, yyjson_mut_val* new_val) {
     if (yyjson_unlikely(!ptr))
       return false;
     return yyjson_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val);
   }
 
   yyjson_api_inline bool yyjson_mut_doc_ptr_setn(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   ) {
     return yyjson_mut_doc_ptr_setx(doc, ptr, len, new_val, true, NULL, NULL);
   }
 
   yyjson_api_inline bool yyjson_mut_doc_ptr_setx(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7596,7 +7090,7 @@ extern "C" {
         return false;
       }
       if (unsafe_yyjson_mut_ptr_putx(
-              root, ptr, len, new_val, doc, create_parent, false, ctx, err
+            root, ptr, len, new_val, doc, create_parent, false, ctx, err
           )) {
         doc->root = root;
         return true;
@@ -7604,15 +7098,15 @@ extern "C" {
       return false;
     }
     return unsafe_yyjson_mut_ptr_putx(
-        doc->root, ptr, len, new_val, doc, create_parent, false, ctx, err
+      doc->root, ptr, len, new_val, doc, create_parent, false, ctx, err
     );
   }
 
   yyjson_api_inline bool yyjson_mut_ptr_set(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   ) {
     if (yyjson_unlikely(!ptr))
       return false;
@@ -7620,24 +7114,24 @@ extern "C" {
   }
 
   yyjson_api_inline bool yyjson_mut_ptr_setn(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc
   ) {
     return yyjson_mut_ptr_setx(val, ptr, len, new_val, doc, true, NULL, NULL);
   }
 
   yyjson_api_inline bool yyjson_mut_ptr_setx(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_mut_doc* doc,
-      bool            create_parent,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_mut_doc* doc,
+    bool            create_parent,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7658,37 +7152,32 @@ extern "C" {
     if (!new_val) {
       return !!unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err);
     }
-    return unsafe_yyjson_mut_ptr_putx(
-        val, ptr, len, new_val, doc, create_parent, false, ctx, err
-    );
+    return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val, doc, create_parent, false, ctx, err);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_replace(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_doc_ptr_replace(yyjson_mut_doc* doc, const char* ptr, yyjson_mut_val* new_val) {
     if (!ptr)
       return NULL;
     return yyjson_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val);
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_replacen(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   ) {
     return yyjson_mut_doc_ptr_replacex(doc, ptr, len, new_val, NULL, NULL);
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_replacex(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7717,37 +7206,32 @@ extern "C" {
       yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
       return NULL;
     }
-    return unsafe_yyjson_mut_ptr_replacex(
-        doc->root, ptr, len, new_val, ctx, err
-    );
+    return unsafe_yyjson_mut_ptr_replacex(doc->root, ptr, len, new_val, ctx, err);
   }
 
-  yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_replace(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      yyjson_mut_val* new_val
-  ) {
+  yyjson_api_inline yyjson_mut_val*
+  yyjson_mut_ptr_replace(yyjson_mut_val* val, const char* ptr, yyjson_mut_val* new_val) {
     if (!ptr)
       return NULL;
     return yyjson_mut_ptr_replacen(val, ptr, strlen(ptr), new_val);
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_replacen(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val
   ) {
     return yyjson_mut_ptr_replacex(val, ptr, len, new_val, NULL, NULL);
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_replacex(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_mut_val* new_val,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_mut_val* new_val,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7781,11 +7265,11 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_ptr_removex(
-      yyjson_mut_doc* doc,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_doc* doc,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7813,8 +7297,7 @@ extern "C" {
     return unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err);
   }
 
-  yyjson_api_inline yyjson_mut_val*
-  yyjson_mut_ptr_remove(yyjson_mut_val* val, const char* ptr) {
+  yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_remove(yyjson_mut_val* val, const char* ptr) {
     if (!ptr)
       return NULL;
     return yyjson_mut_ptr_removen(val, ptr, strlen(ptr));
@@ -7826,11 +7309,11 @@ extern "C" {
   }
 
   yyjson_api_inline yyjson_mut_val* yyjson_mut_ptr_removex(
-      yyjson_mut_val* val,
-      const char*     ptr,
-      size_t          len,
-      yyjson_ptr_ctx* ctx,
-      yyjson_ptr_err* err
+    yyjson_mut_val* val,
+    const char*     ptr,
+    size_t          len,
+    yyjson_ptr_ctx* ctx,
+    yyjson_ptr_err* err
   ) {
     yyjson_ptr_set_err(NONE, NULL);
     if (ctx)
@@ -7851,11 +7334,8 @@ extern "C" {
     return unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err);
   }
 
-  yyjson_api_inline bool yyjson_ptr_ctx_append(
-      yyjson_ptr_ctx* ctx,
-      yyjson_mut_val* key,
-      yyjson_mut_val* val
-  ) {
+  yyjson_api_inline bool
+  yyjson_ptr_ctx_append(yyjson_ptr_ctx* ctx, yyjson_mut_val* key, yyjson_mut_val* val) {
     yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
     if (!ctx || !ctx->ctn || !val)
       return false;
@@ -7911,8 +7391,7 @@ extern "C" {
     return true;
   }
 
-  yyjson_api_inline bool
-  yyjson_ptr_ctx_replace(yyjson_ptr_ctx* ctx, yyjson_mut_val* val) {
+  yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx* ctx, yyjson_mut_val* val) {
     yyjson_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val;
     if (!ctx || !ctx->ctn || !ctx->pre || !val)
       return false;
@@ -7990,8 +7469,7 @@ extern "C" {
    Returns true if value at `ptr` exists and is the correct type, otherwise
    false.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_get_bool(yyjson_val* root, const char* ptr, bool* value) {
+  yyjson_api_inline bool yyjson_ptr_get_bool(yyjson_val* root, const char* ptr, bool* value) {
     yyjson_val* val = yyjson_ptr_get(root, ptr);
     if (value && yyjson_is_bool(val)) {
       *value = unsafe_yyjson_get_bool(val);
@@ -8006,8 +7484,7 @@ extern "C" {
    Returns true if value at `ptr` exists and is the correct type, otherwise
    false.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_get_uint(yyjson_val* root, const char* ptr, uint64_t* value) {
+  yyjson_api_inline bool yyjson_ptr_get_uint(yyjson_val* root, const char* ptr, uint64_t* value) {
     yyjson_val* val = yyjson_ptr_get(root, ptr);
     if (value && yyjson_is_uint(val)) {
       *value = unsafe_yyjson_get_uint(val);
@@ -8022,8 +7499,7 @@ extern "C" {
    Returns true if value at `ptr` exists and is the correct type, otherwise
    false.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_get_sint(yyjson_val* root, const char* ptr, int64_t* value) {
+  yyjson_api_inline bool yyjson_ptr_get_sint(yyjson_val* root, const char* ptr, int64_t* value) {
     yyjson_val* val = yyjson_ptr_get(root, ptr);
     if (value && yyjson_is_sint(val)) {
       *value = unsafe_yyjson_get_sint(val);
@@ -8038,8 +7514,7 @@ extern "C" {
    Returns true if value at `ptr` exists and is the correct type, otherwise
    false.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_get_real(yyjson_val* root, const char* ptr, double* value) {
+  yyjson_api_inline bool yyjson_ptr_get_real(yyjson_val* root, const char* ptr, double* value) {
     yyjson_val* val = yyjson_ptr_get(root, ptr);
     if (value && yyjson_is_real(val)) {
       *value = unsafe_yyjson_get_real(val);
@@ -8055,8 +7530,7 @@ extern "C" {
    Returns true if value at `ptr` exists and is the correct type, otherwise
    false.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_get_num(yyjson_val* root, const char* ptr, double* value) {
+  yyjson_api_inline bool yyjson_ptr_get_num(yyjson_val* root, const char* ptr, double* value) {
     yyjson_val* val = yyjson_ptr_get(root, ptr);
     if (value && yyjson_is_num(val)) {
       *value = unsafe_yyjson_get_num(val);
@@ -8071,8 +7545,7 @@ extern "C" {
    string. Returns true if value at `ptr` exists and is the correct type,
    otherwise false.
    */
-  yyjson_api_inline bool
-  yyjson_ptr_get_str(yyjson_val* root, const char* ptr, const char** value) {
+  yyjson_api_inline bool yyjson_ptr_get_str(yyjson_val* root, const char* ptr, const char** value) {
     yyjson_val* val = yyjson_ptr_get(root, ptr);
     if (value && yyjson_is_str(val)) {
       *value = unsafe_yyjson_get_str(val);
@@ -8087,93 +7560,67 @@ extern "C" {
    *============================================================================*/
 
   /** @deprecated renamed to `yyjson_doc_ptr_get` */
-  yyjson_deprecated("renamed to yyjson_doc_ptr_get") yyjson_api_inline
-      yyjson_val* yyjson_doc_get_pointer(yyjson_doc* doc, const char* ptr) {
+  yyjson_deprecated("renamed to yyjson_doc_ptr_get"
+  ) yyjson_api_inline yyjson_val* yyjson_doc_get_pointer(yyjson_doc* doc, const char* ptr) {
     return yyjson_doc_ptr_get(doc, ptr);
   }
 
   /** @deprecated renamed to `yyjson_doc_ptr_getn` */
-  yyjson_deprecated("renamed to yyjson_doc_ptr_getn")
-      yyjson_api_inline yyjson_val* yyjson_doc_get_pointern(
-          yyjson_doc* doc,
-          const char* ptr,
-          size_t      len
-      ) {
+  yyjson_deprecated("renamed to yyjson_doc_ptr_getn") yyjson_api_inline
+    yyjson_val* yyjson_doc_get_pointern(yyjson_doc* doc, const char* ptr, size_t len) {
     return yyjson_doc_ptr_getn(doc, ptr, len);
   }
 
   /** @deprecated renamed to `yyjson_mut_doc_ptr_get` */
-  yyjson_deprecated("renamed to yyjson_mut_doc_ptr_get")
-      yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_get_pointer(
-          yyjson_mut_doc* doc,
-          const char*     ptr
-      ) {
+  yyjson_deprecated("renamed to yyjson_mut_doc_ptr_get") yyjson_api_inline
+    yyjson_mut_val* yyjson_mut_doc_get_pointer(yyjson_mut_doc* doc, const char* ptr) {
     return yyjson_mut_doc_ptr_get(doc, ptr);
   }
 
   /** @deprecated renamed to `yyjson_mut_doc_ptr_getn` */
-  yyjson_deprecated("renamed to yyjson_mut_doc_ptr_getn")
-      yyjson_api_inline yyjson_mut_val* yyjson_mut_doc_get_pointern(
-          yyjson_mut_doc* doc,
-          const char*     ptr,
-          size_t          len
-      ) {
+  yyjson_deprecated("renamed to yyjson_mut_doc_ptr_getn") yyjson_api_inline
+    yyjson_mut_val* yyjson_mut_doc_get_pointern(yyjson_mut_doc* doc, const char* ptr, size_t len) {
     return yyjson_mut_doc_ptr_getn(doc, ptr, len);
   }
 
   /** @deprecated renamed to `yyjson_ptr_get` */
-  yyjson_deprecated("renamed to yyjson_ptr_get") yyjson_api_inline
-      yyjson_val* yyjson_get_pointer(yyjson_val* val, const char* ptr) {
+  yyjson_deprecated("renamed to yyjson_ptr_get"
+  ) yyjson_api_inline yyjson_val* yyjson_get_pointer(yyjson_val* val, const char* ptr) {
     return yyjson_ptr_get(val, ptr);
   }
 
   /** @deprecated renamed to `yyjson_ptr_getn` */
-  yyjson_deprecated("renamed to yyjson_ptr_getn")
-      yyjson_api_inline yyjson_val* yyjson_get_pointern(
-          yyjson_val* val,
-          const char* ptr,
-          size_t      len
-      ) {
+  yyjson_deprecated("renamed to yyjson_ptr_getn") yyjson_api_inline
+    yyjson_val* yyjson_get_pointern(yyjson_val* val, const char* ptr, size_t len) {
     return yyjson_ptr_getn(val, ptr, len);
   }
 
   /** @deprecated renamed to `yyjson_mut_ptr_get` */
-  yyjson_deprecated("renamed to yyjson_mut_ptr_get")
-      yyjson_api_inline yyjson_mut_val* yyjson_mut_get_pointer(
-          yyjson_mut_val* val,
-          const char*     ptr
-      ) {
+  yyjson_deprecated("renamed to yyjson_mut_ptr_get"
+  ) yyjson_api_inline yyjson_mut_val* yyjson_mut_get_pointer(yyjson_mut_val* val, const char* ptr) {
     return yyjson_mut_ptr_get(val, ptr);
   }
 
   /** @deprecated renamed to `yyjson_mut_ptr_getn` */
-  yyjson_deprecated("renamed to yyjson_mut_ptr_getn")
-      yyjson_api_inline yyjson_mut_val* yyjson_mut_get_pointern(
-          yyjson_mut_val* val,
-          const char*     ptr,
-          size_t          len
-      ) {
+  yyjson_deprecated("renamed to yyjson_mut_ptr_getn") yyjson_api_inline
+    yyjson_mut_val* yyjson_mut_get_pointern(yyjson_mut_val* val, const char* ptr, size_t len) {
     return yyjson_mut_ptr_getn(val, ptr, len);
   }
 
   /** @deprecated renamed to `yyjson_mut_ptr_getn` */
-  yyjson_deprecated("renamed to unsafe_yyjson_ptr_getn")
-      yyjson_api_inline yyjson_val* unsafe_yyjson_get_pointer(
-          yyjson_val* val,
-          const char* ptr,
-          size_t      len
-      ) {
+  yyjson_deprecated("renamed to unsafe_yyjson_ptr_getn") yyjson_api_inline
+    yyjson_val* unsafe_yyjson_get_pointer(yyjson_val* val, const char* ptr, size_t len) {
     yyjson_ptr_err err;
     return unsafe_yyjson_ptr_getx(val, ptr, len, &err);
   }
 
   /** @deprecated renamed to `unsafe_yyjson_mut_ptr_getx` */
   yyjson_deprecated("renamed to unsafe_yyjson_mut_ptr_getx")
-      yyjson_api_inline yyjson_mut_val* unsafe_yyjson_mut_get_pointer(
-          yyjson_mut_val* val,
-          const char*     ptr,
-          size_t          len
-      ) {
+    yyjson_api_inline yyjson_mut_val* unsafe_yyjson_mut_get_pointer(
+      yyjson_mut_val* val,
+      const char*     ptr,
+      size_t          len
+    ) {
     yyjson_ptr_err err;
     return unsafe_yyjson_mut_ptr_getx(val, ptr, len, NULL, &err);
   }
diff --git a/meson.build b/meson.build
index eb0e6bb..4791131 100644
--- a/meson.build
+++ b/meson.build
@@ -4,7 +4,7 @@ project(
   default_options: [
     'objc_std=c++20',
     'objcpp_std=c++20',
-    'cpp_std=c++20',
+    'cpp_std=c++23',
     'default_library=static',
     'warning_level=everything',
     'buildtype=debugoptimized'
@@ -76,17 +76,10 @@ endforeach
 
 deps = []
 
-fmt     = dependency('fmt', required: false)
-libcurl = dependency('libcurl', required: false)
-tomlpp  = dependency('tomlplusplus', required: false)
-yyjson  = dependency('yyjson', required: false)
-
-foreach dep : [fmt, libcurl, tomlpp, yyjson]
-  if not dep.found()
-    dep = cpp.find_library(dep.name(), required: true)
-  endif
-  deps += dep
-endforeach
+deps += cpp.find_library('fmt', required: false)
+deps += dependency('libcurl', required: false)
+deps += dependency('tomlplusplus', required: false)
+deps += cpp.find_library('yyjson', required: false)
 
 if host_machine.system() == 'darwin'
   deps += dependency('Foundation')
@@ -94,11 +87,18 @@ if host_machine.system() == 'darwin'
 endif
 
 if host_machine.system() == 'linux'
-  deps += dependency('sdbus-c++')
+  deps += cpp.find_library('sdbus-c++')
 endif
 
+foreach dep : deps
+  if not dep.found()
+    dep = cpp.find_library(dep.name(), required: true)
+  endif
+  deps += dep
+endforeach
+
 incdir = include_directories(
-  ['include', '/nix/store/pp85qmfpf239b75sm23hhx6cvxfrr4p9-fmt-10.2.1-dev/include'],
+  'include',
   is_system: true # Ignores warnings from include dir
 )
 
diff --git a/src/config/config.cpp b/src/config/config.cpp
index 0a2ba94..8acaea9 100644
--- a/src/config/config.cpp
+++ b/src/config/config.cpp
@@ -1,26 +1,5 @@
 #include "config.h"
 
-// -------------
-// -- Weather --
-// -------------
-DEFINE_GETTER(Weather, const Weather::Location, Location)
-DEFINE_GETTER(Weather, const std::string, ApiKey)
-DEFINE_GETTER(Weather, const std::string, Units)
-
-Weather::Weather(Location location, std::string api_key, std::string units)
-    : m_Location(std::move(location)), m_ApiKey(std::move(api_key)), m_Units(std::move(units)) {}
-
-fn WeatherImpl::from_class(const Weather& weather) noexcept -> WeatherImpl {
-  return {
-      .location = weather.getLocation(),
-      .api_key  = weather.getApiKey(),
-      .units    = weather.getUnits(),
-  };
-}
-
-fn WeatherImpl::to_class() const -> Weather { return {location, api_key, units}; }
-// ------------
-
 // -------------
 // -- General --
 // -------------
@@ -28,9 +7,11 @@ DEFINE_GETTER(General, const std::string, Name)
 
 General::General(std::string name) : m_Name(std::move(name)) {}
 
-fn GeneralImpl::from_class(const General& general) -> GeneralImpl { return {general.getName()}; }
+fn GeneralImpl::from_class(const General& instance) noexcept -> GeneralImpl {
+  return { instance.getName() };
+}
 
-fn GeneralImpl::to_class() const -> General { return {name}; }
+fn GeneralImpl::to_class() const -> General { return General { name }; }
 // -------------
 
 // ----------------
@@ -40,11 +21,11 @@ DEFINE_GETTER(NowPlaying, bool, Enabled)
 
 NowPlaying::NowPlaying(bool enabled) : m_Enabled(enabled) {}
 
-fn NowPlayingImpl::from_class(const NowPlaying& now_playing) -> NowPlayingImpl {
-  return {.enabled = now_playing.getEnabled()};
+fn NowPlayingImpl::from_class(const NowPlaying& instance) noexcept -> NowPlayingImpl {
+  return { .enabled = instance.getEnabled() };
 }
 
-fn NowPlayingImpl::to_class() const -> NowPlaying { return {enabled.value_or(false)}; }
+fn NowPlayingImpl::to_class() const -> NowPlaying { return NowPlaying { enabled.value_or(false) }; }
 // ----------------
 
 // ------------
@@ -55,20 +36,20 @@ DEFINE_GETTER(Config, const NowPlaying, NowPlaying)
 DEFINE_GETTER(Config, const Weather, Weather)
 
 Config::Config(General general, NowPlaying now_playing, Weather weather)
-    : m_General(std::move(general)), m_NowPlaying(now_playing), m_Weather(std::move(weather)) {}
+  : m_General(std::move(general)), m_NowPlaying(now_playing), m_Weather(std::move(weather)) {}
 
 fn Config::getInstance() -> const Config& {
   static const auto* INSTANCE = new Config(rfl::toml::load<Config>("./config.toml").value());
   return *INSTANCE;
 }
 
-fn ConfigImpl::from_class(const Config& config) -> ConfigImpl {
+fn ConfigImpl::from_class(const Config& instance) noexcept -> ConfigImpl {
   return {
-      .general     = config.getGeneral(),
-      .now_playing = config.getNowPlaying(),
-      .weather     = config.getWeather(),
+    instance.getGeneral(),
+    instance.getNowPlaying(),
+    instance.getWeather(),
   };
 }
 
-fn ConfigImpl::to_class() const -> Config { return {general, now_playing, weather}; }
+fn ConfigImpl::to_class() const -> Config { return { general, now_playing, weather }; }
 // ------------
diff --git a/src/config/config.h b/src/config/config.h
index c0d3478..343827a 100644
--- a/src/config/config.h
+++ b/src/config/config.h
@@ -1,8 +1,6 @@
 #pragma once
 
-#include <fmt/core.h>
 #include <rfl.hpp>
-#include <rfl/toml.hpp>
 #include <string>
 
 #include "util/macros.h"
@@ -15,7 +13,7 @@ class General {
   std::string m_Name;
 
  public:
-  General(std::string name);
+  explicit General(std::string name);
 
   [[nodiscard]] fn getName() const -> const std::string;
 };
@@ -25,7 +23,7 @@ class NowPlaying {
   bool m_Enabled;
 
  public:
-  NowPlaying(bool enabled);
+  explicit NowPlaying(bool enabled);
 
   [[nodiscard]] fn getEnabled() const -> bool;
 };
@@ -37,8 +35,20 @@ class Config {
   Weather    m_Weather;
 
  public:
+  /**
+   * @brief Creates a new Config instance.
+   *
+   * @param general     The general section of the configuration.
+   * @param now_playing The now playing section of the configuration.
+   * @param weather     The weather section of the configuration.
+   */
   Config(General general, NowPlaying now_playing, Weather weather);
 
+  /**
+   * @brief Gets the current (read-only) configuration.
+   *
+   * @return The current Config instance.
+   */
   static fn getInstance() -> const Config&;
 
   [[nodiscard]] fn getWeather() const -> const Weather;
@@ -47,20 +57,20 @@ class Config {
 };
 
 // reflect-cpp Stuff
-DEF_IMPL(General, general, std::string name)
-DEF_IMPL(NowPlaying, now_playing, std::optional<bool> enabled)
-DEF_IMPL(Config, config, General general; NowPlaying now_playing; Weather weather)
+DEF_IMPL(General, std::string name)
+DEF_IMPL(NowPlaying, std::optional<bool> enabled)
+DEF_IMPL(Config, General general; NowPlaying now_playing; Weather weather)
 
 namespace rfl::parsing {
   template <class ReaderType, class WriterType, class ProcessorsType>
   struct Parser<ReaderType, WriterType, General, ProcessorsType>
-      : public CustomParser<ReaderType, WriterType, ProcessorsType, General, GeneralImpl> {};
+    : CustomParser<ReaderType, WriterType, ProcessorsType, General, GeneralImpl> {};
 
   template <class ReaderType, class WriterType, class ProcessorsType>
   struct Parser<ReaderType, WriterType, NowPlaying, ProcessorsType>
-      : public CustomParser<ReaderType, WriterType, ProcessorsType, NowPlaying, NowPlayingImpl> {};
+    : CustomParser<ReaderType, WriterType, ProcessorsType, NowPlaying, NowPlayingImpl> {};
 
   template <class ReaderType, class WriterType, class ProcessorsType>
   struct Parser<ReaderType, WriterType, Config, ProcessorsType>
-      : public CustomParser<ReaderType, WriterType, ProcessorsType, Config, ConfigImpl> {};
+    : CustomParser<ReaderType, WriterType, ProcessorsType, Config, ConfigImpl> {};
 }
diff --git a/src/config/weather.cpp b/src/config/weather.cpp
index 8b4a03f..bfb70cd 100644
--- a/src/config/weather.cpp
+++ b/src/config/weather.cpp
@@ -7,6 +7,23 @@
 
 #include "util/result.h"
 
+DEFINE_GETTER(Weather, const Weather::Location, Location)
+DEFINE_GETTER(Weather, const std::string, ApiKey)
+DEFINE_GETTER(Weather, const std::string, Units)
+
+Weather::Weather(Location location, std::string api_key, std::string units)
+  : m_Location(std::move(location)), m_ApiKey(std::move(api_key)), m_Units(std::move(units)) {}
+
+fn WeatherImpl::from_class(const Weather& weather) noexcept -> WeatherImpl {
+  return {
+    weather.getLocation(),
+    weather.getApiKey(),
+    weather.getUnits(),
+  };
+}
+
+fn WeatherImpl::to_class() const -> Weather { return { location, api_key, units }; }
+
 using WeatherOutput = Weather::WeatherOutput;
 
 // Function to read cache from file
@@ -49,8 +66,7 @@ fn WriteCacheToFile(const WeatherOutput& data) -> Result<> {
   return Ok();
 }
 
-fn WriteCallback(void* contents, size_t size, size_t nmemb, std::string* str)
-    -> size_t {
+fn WriteCallback(void* contents, size_t size, size_t nmemb, std::string* str) -> size_t {
   size_t totalSize = size * nmemb;
   str->append(static_cast<char*>(contents), totalSize);
   return totalSize;
@@ -71,17 +87,12 @@ fn MakeApiRequest(const std::string& url) -> Result<WeatherOutput> {
     curl_easy_cleanup(curl);
 
     if (res != CURLE_OK) {
-      return Error(fmt::format(
-          "Failed to perform cURL request: {}", curl_easy_strerror(res)
-      ));
+      return Error(fmt::format("Failed to perform cURL request: {}", curl_easy_strerror(res)));
     }
 
-    fmt::println(
-        "Received response from API. Response size: {}", responseBuffer.size()
-    );
+    fmt::println("Received response from API. Response size: {}", responseBuffer.size());
 
-    WeatherOutput output =
-        rfl::json::read<WeatherOutput>(responseBuffer).value();
+    WeatherOutput output = rfl::json::read<WeatherOutput>(responseBuffer).value();
 
     return Ok(output); // Return an empty result for now
   }
@@ -118,18 +129,16 @@ fn Weather::getWeatherInfo() const -> WeatherOutput {
   if (holds_alternative<std::string>(loc)) {
     const std::string city = get<std::string>(loc);
 
-    const char* location = curl_easy_escape(
-        nullptr, city.c_str(), static_cast<int>(city.length())
-    );
+    const char* location = curl_easy_escape(nullptr, city.c_str(), static_cast<int>(city.length()));
 
     fmt::println("City: {}", location);
 
     const std::string apiUrl = fmt::format(
-        "https://api.openweathermap.org/data/2.5/"
-        "weather?q={}&appid={}&units={}",
-        location,
-        apiKey,
-        units
+      "https://api.openweathermap.org/data/2.5/"
+      "weather?q={}&appid={}&units={}",
+      location,
+      apiKey,
+      units
     );
 
     result = MakeApiRequest(apiUrl).value();
@@ -139,12 +148,12 @@ fn Weather::getWeatherInfo() const -> WeatherOutput {
     fmt::println("Coordinates: lat = {:.3f}, lon = {:.3f}", lat, lon);
 
     const std::string apiUrl = fmt::format(
-        "https://api.openweathermap.org/data/2.5/"
-        "weather?lat={:.3f}&lon={:.3f}&appid={}&units={}",
-        lat,
-        lon,
-        apiKey,
-        units
+      "https://api.openweathermap.org/data/2.5/"
+      "weather?lat={:.3f}&lon={:.3f}&appid={}&units={}",
+      lat,
+      lon,
+      apiKey,
+      units
     );
 
     result = MakeApiRequest(apiUrl).value();
diff --git a/src/config/weather.h b/src/config/weather.h
index 4be9afa..4987507 100644
--- a/src/config/weather.h
+++ b/src/config/weather.h
@@ -94,23 +94,10 @@ class Weather {
   [[nodiscard]] fn getUnits() const -> const std::string;
 };
 
-struct WeatherImpl {
-  Weather::Location location;
-  std::string       api_key;
-  std::string       units;
-
-  static fn from_class(const Weather& weather) noexcept -> WeatherImpl;
-
-  [[nodiscard]] fn to_class() const -> Weather;
-};
+DEF_IMPL(Weather, Weather::Location location; std::string api_key; std::string units)
 
 namespace rfl::parsing {
   template <class ReaderType, class WriterType, class ProcessorsType>
   struct Parser<ReaderType, WriterType, Weather, ProcessorsType>
-      : public CustomParser<
-            ReaderType,
-            WriterType,
-            ProcessorsType,
-            Weather,
-            WeatherImpl> {};
+    : CustomParser<ReaderType, WriterType, ProcessorsType, Weather, WeatherImpl> {};
 }
diff --git a/src/main.cpp b/src/main.cpp
index 2696d6c..eca51f9 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -18,7 +18,7 @@ struct fmt::formatter<BytesToGiB> : formatter<double> {
   template <typename FmtCtx>
   fn format(const BytesToGiB BTG, FmtCtx& ctx) -> typename FmtCtx::iterator {
     typename FmtCtx::iterator out =
-        formatter<double>::format(static_cast<double>(BTG.value) / GIB, ctx);
+      formatter<double>::format(static_cast<double>(BTG.value) / GIB, ctx);
     *out++ = 'G';
     *out++ = 'i';
     *out++ = 'B';
@@ -62,7 +62,7 @@ fn main() -> int {
   fmt::println("Hello {}!", name);
   fmt::println("Today is: {}", GetDate());
   fmt::println("It is {}°F in {}", temp, townName);
-  fmt::println("Installed RAM: {:.2f}", BytesToGiB {GetMemInfo()});
+  fmt::println("Installed RAM: {:.2f}", BytesToGiB { GetMemInfo() });
   fmt::println("{}", version);
 
   if (nowPlayingEnabled)
diff --git a/src/os/linux.cpp b/src/os/linux.cpp
index cc19c41..96d1f6e 100644
--- a/src/os/linux.cpp
+++ b/src/os/linux.cpp
@@ -10,7 +10,7 @@
 
 using std::string;
 
-u64 ParseLineAsNumber(const string& input) {
+fn ParseLineAsNumber(const string& input) -> u64 {
   // Find the first number
   string::size_type start = 0;
 
@@ -27,7 +27,7 @@ u64 ParseLineAsNumber(const string& input) {
   return std::stoul(input.substr(start, end - start));
 }
 
-u64 MeminfoParse(std::ifstream input) {
+fn MeminfoParse(std::ifstream input) -> u64 {
   string line;
 
   // Skip every line before the one that starts with "MemTotal"
@@ -39,9 +39,9 @@ u64 MeminfoParse(std::ifstream input) {
   return num;
 }
 
-u64 GetMemInfo() { return MeminfoParse(std::ifstream("/proc/meminfo")) * 1024; }
+fn GetMemInfo() -> u64 { return MeminfoParse(std::ifstream("/proc/meminfo")) * 1024; }
 
-const char* GetOSVersion() {
+fn GetOSVersion() -> const char* {
   std::ifstream file("/etc/os-release");
 
   if (!file.is_open()) {
@@ -57,12 +57,8 @@ const char* GetOSVersion() {
       std::string prettyName = line.substr(prefix.size());
 
       // Remove surrounding quotes if present
-      // clang-format off
-      if (!prettyName.empty() &&
-           prettyName.front() == '"' &&
-           prettyName.back()  == '"')
+      if (!prettyName.empty() && prettyName.front() == '"' && prettyName.back() == '"')
         prettyName = prettyName.substr(1, prettyName.size() - 2);
-      // clang-format on
 
       // Allocate memory for the C-string and copy the content
       char* cstr = new char[prettyName.size() + 1];
@@ -75,44 +71,40 @@ const char* GetOSVersion() {
   return nullptr;
 }
 
-std::vector<std::string> GetMprisPlayers(sdbus::IConnection& connection) {
-  const char *dbusInterface       = "org.freedesktop.DBus",
-             *dbusObjectPath      = "/org/freedesktop/DBus",
-             *dbusMethodListNames = "ListNames",
-             *mprisInterfaceName  = "org.mpris.MediaPlayer2";
+fn GetMprisPlayers(sdbus::IConnection& connection) -> std::vector<std::string> {
+  const char *dbusInterface = "org.freedesktop.DBus", *dbusObjectPath = "/org/freedesktop/DBus",
+             *dbusMethodListNames = "ListNames";
 
-  std::unique_ptr<sdbus::IProxy> dbusProxy =
-      sdbus::createProxy(connection, dbusInterface, dbusObjectPath);
+  const std::unique_ptr<sdbus::IProxy> dbusProxy =
+    createProxy(connection, dbusInterface, dbusObjectPath);
 
   std::vector<std::string> names;
 
-  dbusProxy->callMethod(dbusMethodListNames)
-      .onInterface(dbusInterface)
-      .storeResultsTo(names);
+  dbusProxy->callMethod(dbusMethodListNames).onInterface(dbusInterface).storeResultsTo(names);
 
   std::vector<std::string> mprisPlayers;
 
   for (const std::basic_string<char>& name : names)
-    if (name.contains(mprisInterfaceName))
+    if (const char* mprisInterfaceName = "org.mpris.MediaPlayer2";
+        name.contains(mprisInterfaceName))
       mprisPlayers.push_back(name);
 
   return mprisPlayers;
 }
 
-std::string GetActivePlayer(const std::vector<std::string>& mprisPlayers) {
+fn GetActivePlayer(const std::vector<std::string>& mprisPlayers) -> std::string {
   if (!mprisPlayers.empty())
     return mprisPlayers.front();
 
   return "";
 }
 
-std::string GetNowPlaying() {
+fn GetNowPlaying() -> std::string {
   try {
     const char *playerObjectPath    = "/org/mpris/MediaPlayer2",
                *playerInterfaceName = "org.mpris.MediaPlayer2.Player";
 
-    std::unique_ptr<sdbus::IConnection> connection =
-        sdbus::createSessionBusConnection();
+    std::unique_ptr<sdbus::IConnection> connection = sdbus::createSessionBusConnection();
 
     std::vector<std::string> mprisPlayers = GetMprisPlayers(*connection);
 
@@ -125,19 +117,16 @@ std::string GetNowPlaying() {
       return "";
 
     std::unique_ptr<sdbus::IProxy> playerProxy =
-        sdbus::createProxy(*connection, activePlayer, playerObjectPath);
+      sdbus::createProxy(*connection, activePlayer, playerObjectPath);
 
     std::map<std::string, sdbus::Variant> metadata =
-        playerProxy->getProperty("Metadata").onInterface(playerInterfaceName);
+      playerProxy->getProperty("Metadata").onInterface(playerInterfaceName);
 
-    auto iter = metadata.find("xesam:title");
+    if (const auto iter = metadata.find("xesam:title");
 
-    if (iter != metadata.end() &&
-        iter->second.containsValueOfType<std::string>())
+        iter != metadata.end() && iter->second.containsValueOfType<std::string>())
       return iter->second.get<std::string>();
-  } catch (const sdbus::Error& e) {
-    std::cerr << "Error: " << e.what() << std::endl;
-  }
+  } catch (const sdbus::Error& e) { std::cerr << "Error: " << e.what() << '\n'; }
 
   return "";
 }
diff --git a/src/os/macos.cpp b/src/os/macos.cpp
index b1ae63a..1cc8de5 100644
--- a/src/os/macos.cpp
+++ b/src/os/macos.cpp
@@ -15,8 +15,7 @@ fn GetMemInfo() -> u64 {
 }
 
 fn GetNowPlaying() -> std::string {
-  if (const char* title  = GetCurrentPlayingTitle();
-      const char* artist = GetCurrentPlayingArtist())
+  if (const char* title = GetCurrentPlayingTitle(); const char* artist = GetCurrentPlayingArtist())
     return "Now Playing: " + std::string(artist) + " - " + std::string(title);
 
   return "No song playing";
diff --git a/src/os/macos/bridge.mm b/src/os/macos/bridge.mm
index 61f16f1..d22ce6a 100644
--- a/src/os/macos/bridge.mm
+++ b/src/os/macos/bridge.mm
@@ -5,18 +5,16 @@
 
 #import "bridge.h"
 
-using MRMediaRemoteGetNowPlayingInfoFunction = void (*)(
-    dispatch_queue_t queue,
-    void (^handler)(NSDictionary* information)
-);
+using MRMediaRemoteGetNowPlayingInfoFunction =
+  void (*)(dispatch_queue_t queue, void (^handler)(NSDictionary* information));
 
 @implementation Bridge
 + (NSDictionary*)currentPlayingMetadata {
   CFURLRef ref = CFURLCreateWithFileSystemPath(
-      kCFAllocatorDefault,
-      CFSTR("/System/Library/PrivateFrameworks/MediaRemote.framework"),
-      kCFURLPOSIXPathStyle,
-      false
+    kCFAllocatorDefault,
+    CFSTR("/System/Library/PrivateFrameworks/MediaRemote.framework"),
+    kCFURLPOSIXPathStyle,
+    false
   );
 
   if (!ref) {
@@ -33,11 +31,9 @@ using MRMediaRemoteGetNowPlayingInfoFunction = void (*)(
   }
 
   MRMediaRemoteGetNowPlayingInfoFunction mrMediaRemoteGetNowPlayingInfo =
-      reinterpret_cast<MRMediaRemoteGetNowPlayingInfoFunction>(
-          CFBundleGetFunctionPointerForName(
-              bundle, CFSTR("MRMediaRemoteGetNowPlayingInfo")
-          )
-      );
+    reinterpret_cast<MRMediaRemoteGetNowPlayingInfoFunction>(
+      CFBundleGetFunctionPointerForName(bundle, CFSTR("MRMediaRemoteGetNowPlayingInfo"))
+    );
 
   if (!mrMediaRemoteGetNowPlayingInfo) {
     NSLog(@"Failed to get function pointer for MRMediaRemoteGetNowPlayingInfo");
@@ -49,11 +45,11 @@ using MRMediaRemoteGetNowPlayingInfoFunction = void (*)(
   dispatch_semaphore_t  semaphore      = dispatch_semaphore_create(0);
 
   mrMediaRemoteGetNowPlayingInfo(
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
-      ^(NSDictionary* information) {
-        nowPlayingInfo = [information copy];
-        dispatch_semaphore_signal(semaphore);
-      }
+    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
+    ^(NSDictionary* information) {
+      nowPlayingInfo = [information copy];
+      dispatch_semaphore_signal(semaphore);
+    }
   );
 
   dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
@@ -69,9 +65,8 @@ using MRMediaRemoteGetNowPlayingInfoFunction = void (*)(
 
   NSString* version;
   if (osVersion.patchVersion == 0) {
-    version = [NSString stringWithFormat:@"%ld.%ld",
-                                         osVersion.majorVersion,
-                                         osVersion.minorVersion];
+    version =
+      [NSString stringWithFormat:@"%ld.%ld", osVersion.majorVersion, osVersion.minorVersion];
   } else {
     version = [NSString stringWithFormat:@"%ld.%ld.%ld",
                                          osVersion.majorVersion,
@@ -80,13 +75,8 @@ using MRMediaRemoteGetNowPlayingInfoFunction = void (*)(
   }
 
   // Dictionary to map macOS versions to their respective names
-  NSDictionary<NSNumber*, NSString*>* versionNames = @{
-    @11 : @"Big Sur",
-    @12 : @"Monterey",
-    @13 : @"Ventura",
-    @14 : @"Sonoma",
-    @15 : @"Sequoia"
-  };
+  NSDictionary<NSNumber*, NSString*>* versionNames =
+    @{ @11 : @"Big Sur", @12 : @"Monterey", @13 : @"Ventura", @14 : @"Sonoma", @15 : @"Sequoia" };
 
   NSNumber* majorVersionNumber = @(osVersion.majorVersion);
   NSString* versionName        = versionNames[majorVersionNumber];
@@ -94,8 +84,7 @@ using MRMediaRemoteGetNowPlayingInfoFunction = void (*)(
   if (versionName == nil)
     versionName = @"Unknown";
 
-  NSString* fullVersion =
-      [NSString stringWithFormat:@"macOS %@ %@", version, versionName];
+  NSString* fullVersion = [NSString stringWithFormat:@"macOS %@ %@", version, versionName];
 
   return fullVersion;
 }
@@ -110,8 +99,7 @@ extern "C" {
     if (metadata == nil)
       return nullptr;
 
-    NSString* title =
-        [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoTitle"];
+    NSString* title = [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoTitle"];
 
     if (title)
       return strdup([title UTF8String]);
@@ -125,8 +113,7 @@ extern "C" {
     if (metadata == nil)
       return nullptr;
 
-    NSString* artist =
-        [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoArtist"];
+    NSString* artist = [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoArtist"];
 
     if (artist)
       return strdup([artist UTF8String]);