diff --git a/fuzztest/internal/meta.h b/fuzztest/internal/meta.h
index d03d9e5..9a918e1 100644
--- a/fuzztest/internal/meta.h
+++ b/fuzztest/internal/meta.h
@@ -225,7 +225,7 @@
 auto BindAggregate(T&, std::integral_constant<int, 0>) {
   return std::tie();
 }
-// Implement the overloads from 1 to 32.
+// Implement the overloads from 1 to 64.
 // There is no "variadic" way of doing this.
 #define FUZZTEST_INTERNAL_BIND_AGGREGATE_(n, ...)                \
   template <typename T>                                          \
@@ -305,18 +305,200 @@
                                   x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                   x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                   x29, x30, x31, x32);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(33, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(34, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(35, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(36, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(37, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(38, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(39, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(40, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(41, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(42, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(43, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(44, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(45, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(46, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(47, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(48, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(49, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(50, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(51, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(52, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(53, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(54, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(55, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(56, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(57, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(58, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(59, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58, x59);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(60, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58, x59, x60);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(61, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58, x59, x60, x61);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(62, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58, x59, x60, x61, x62);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(63, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58, x59, x60, x61, x62, x63);
+FUZZTEST_INTERNAL_BIND_AGGREGATE_(64, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
+                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
+                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
+                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
+                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
+                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
+                                  x56, x57, x58, x59, x60, x61, x62, x63, x64);
 #undef FUZZTEST_INTERNAL_BIND_AGGREGATE_
 
-// For N > 32, use std::get<I>.
+// For N > 64, use std::get<I>.
 // Some aggregate types like std::tuple provide this protocol, but so can user
 // defined types.
 template <typename T, int N>
 auto BindAggregate(T& value, std::integral_constant<int, N>) {
-  static_assert(N > 32);
+  static_assert(N > 64);
   if constexpr (std::is_aggregate_v<T> &&
                 !Requires<T>([](auto v) -> decltype(std::get<0>(v)) {})) {
     static_assert(always_false<T>,
-                  "Aggregate types are only supported up to 32 fields.");
+                  "Aggregate types are only supported up to 64 fields.");
   }
   // For the rest use the tuple API
   return ApplyIndex<N>(
@@ -333,8 +515,21 @@
   }
 };
 
+// Try to call ApplyIndex from I all the way down to 0.
+template <size_t I, typename F>
+constexpr std::optional<int> ApplyIndexFor(F f) {
+  if constexpr (ApplyIndex<I>(f)) {
+    return I;
+  }
+  if constexpr (I == 0) {
+    return std::nullopt;
+  } else {
+    return ApplyIndexFor<I - 1>(f);
+  }
+}
+
 // Try applying aggregate initialization to `T` with different number of
-// arguments. We start at 32 and go down until one works.
+// arguments. We start at 64 and go down until one works.
 template <typename T>
 constexpr std::optional<int> DetectBraceInitCount() {
   constexpr auto can_init_impl =
@@ -344,75 +539,9 @@
   };
   if constexpr (!std::is_aggregate_v<T>) {
     return std::nullopt;
-  } else if constexpr (ApplyIndex<32>(can_init)) {
-    return 32;
-  } else if constexpr (ApplyIndex<31>(can_init)) {
-    return 31;
-  } else if constexpr (ApplyIndex<30>(can_init)) {
-    return 30;
-  } else if constexpr (ApplyIndex<29>(can_init)) {
-    return 29;
-  } else if constexpr (ApplyIndex<28>(can_init)) {
-    return 28;
-  } else if constexpr (ApplyIndex<27>(can_init)) {
-    return 27;
-  } else if constexpr (ApplyIndex<26>(can_init)) {
-    return 26;
-  } else if constexpr (ApplyIndex<25>(can_init)) {
-    return 25;
-  } else if constexpr (ApplyIndex<24>(can_init)) {
-    return 24;
-  } else if constexpr (ApplyIndex<23>(can_init)) {
-    return 23;
-  } else if constexpr (ApplyIndex<22>(can_init)) {
-    return 22;
-  } else if constexpr (ApplyIndex<21>(can_init)) {
-    return 21;
-  } else if constexpr (ApplyIndex<20>(can_init)) {
-    return 20;
-  } else if constexpr (ApplyIndex<19>(can_init)) {
-    return 19;
-  } else if constexpr (ApplyIndex<18>(can_init)) {
-    return 18;
-  } else if constexpr (ApplyIndex<17>(can_init)) {
-    return 17;
-  } else if constexpr (ApplyIndex<16>(can_init)) {
-    return 16;
-  } else if constexpr (ApplyIndex<15>(can_init)) {
-    return 15;
-  } else if constexpr (ApplyIndex<14>(can_init)) {
-    return 14;
-  } else if constexpr (ApplyIndex<13>(can_init)) {
-    return 13;
-  } else if constexpr (ApplyIndex<12>(can_init)) {
-    return 12;
-  } else if constexpr (ApplyIndex<11>(can_init)) {
-    return 11;
-  } else if constexpr (ApplyIndex<10>(can_init)) {
-    return 10;
-  } else if constexpr (ApplyIndex<9>(can_init)) {
-    return 9;
-  } else if constexpr (ApplyIndex<8>(can_init)) {
-    return 8;
-  } else if constexpr (ApplyIndex<7>(can_init)) {
-    return 7;
-  } else if constexpr (ApplyIndex<6>(can_init)) {
-    return 6;
-  } else if constexpr (ApplyIndex<5>(can_init)) {
-    return 5;
-  } else if constexpr (ApplyIndex<4>(can_init)) {
-    return 4;
-  } else if constexpr (ApplyIndex<3>(can_init)) {
-    return 3;
-  } else if constexpr (ApplyIndex<2>(can_init)) {
-    return 2;
-  } else if constexpr (ApplyIndex<1>(can_init)) {
-    return 1;
-  } else if constexpr (ApplyIndex<0>(can_init)) {
-    return 0;
-  } else {
-    return std::nullopt;
   }
+
+  return ApplyIndexFor<64>(can_init);
 }
 
 // This allows us to determine whether T has a base class. If it does, it is